]> git.saurik.com Git - wxWidgets.git/blob - utils/tex2rtf/src/rtfutils.cpp
Moved the popup menu event handlers to dialog event handler
[wxWidgets.git] / utils / tex2rtf / src / rtfutils.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: rtfutils.cpp
3 // Purpose: Converts Latex to Word RTF/WinHelp RTF
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 7.9.93
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/wx.h"
25 #endif
26
27 #include "tex2any.h"
28 #include "tex2rtf.h"
29 #include <ctype.h>
30 #include <stdlib.h>
31 #include <stdio.h>
32
33 #ifdef __WIN32__
34 #include <windows.h>
35 #endif
36
37 #include "bmputils.h"
38 #include "table.h"
39
40 wxList itemizeStack;
41 static int indentLevel = 0;
42 static int forbidParindent = 0; // if > 0, no parindent (e.g. in center environment)
43 int forbidResetPar = 0; // If > 0, don't reset memory of having output a new par
44
45 static char *contentsLineSection = NULL;
46 static char *contentsLineValue = NULL;
47 static TexChunk *descriptionItemArg = NULL;
48 static wxStringList environmentStack; // Stack of paragraph styles we need to remember
49 static int footnoteCount = 0;
50 static int citeCount = 1;
51 extern char *FileRoot;
52 extern bool winHelp;
53 extern bool startedSections;
54 extern FILE *Contents;
55 extern FILE *Chapters;
56 extern FILE *Popups;
57 extern FILE *WinHelpContentsFile;
58 extern char *RTFCharset;
59 // This is defined in the Tex2Any library and isn't in use after parsing
60 extern char *BigBuffer;
61
62 extern wxHashTable TexReferences;
63
64 // Are we in verbatim mode? If so, format differently.
65 static bool inVerbatim = FALSE;
66
67 // We're in a series of PopRef topics, so don't output section headings
68 bool inPopRefSection = FALSE;
69
70 // Green colour?
71 static bool hotSpotColour = TRUE;
72 static bool hotSpotUnderline = TRUE;
73
74 // Transparency (WHITE = transparent)
75 static bool bitmapTransparency = TRUE;
76
77 // Linear RTF requires us to set the style per section.
78 static char *currentNumberStyle = NULL;
79 static int currentItemSep = 8;
80 static int CurrentTextWidth = 8640; // Say, six inches
81 static int CurrentLeftMarginOdd = 400;
82 static int CurrentLeftMarginEven = 1440;
83 static int CurrentRightMarginOdd = 1440;
84 static int CurrentRightMarginEven = 400;
85 static int CurrentMarginParWidth = 2000;
86 static int CurrentMarginParSep = 400; // Gap between marginpar and text
87 static int CurrentMarginParX = CurrentLeftMarginOdd + CurrentTextWidth + CurrentMarginParSep;
88 static int GutterWidth = 2300;
89
90 // Two-column table dimensions, in twips
91 static int TwoColWidthA = 1500;
92 static int TwoColWidthB = 3000;
93
94 const int PageWidth = 12242; // 8.25 inches wide for A4
95
96 // Remember the anchor in a helpref
97 static TexChunk *helpRefText = NULL;
98
99 /*
100 * Flag to say we've just issued a \par\pard command, so don't
101 * repeat this unnecessarily.
102 *
103 */
104
105 int issuedNewParagraph = 0;
106
107 // Need to know whether we're in a table or figure for benefit
108 // of listoffigures/listoftables
109 static bool inFigure = FALSE;
110 static bool inTable = FALSE;
111
112 /*
113 * Current topics
114 *
115 */
116 static char *CurrentChapterName = NULL;
117 static char *CurrentSectionName = NULL;
118 static char *CurrentSubsectionName = NULL;
119 static char *CurrentTopic = NULL;
120
121 static bool InPopups()
122 {
123 if (CurrentChapterName && (strcmp(CurrentChapterName, "popups") == 0))
124 return TRUE;
125 if (CurrentSectionName && (strcmp(CurrentSectionName, "popups") == 0))
126 return TRUE;
127 return FALSE;
128 }
129
130 static void SetCurrentTopic(char *s)
131 {
132 if (CurrentTopic) delete[] CurrentTopic;
133 CurrentTopic = copystring(s);
134 }
135
136 void SetCurrentChapterName(char *s)
137 {
138 if (CurrentChapterName) delete[] CurrentChapterName;
139 CurrentChapterName = copystring(s);
140 SetCurrentTopic(s);
141 }
142 void SetCurrentSectionName(char *s)
143 {
144 if (CurrentSectionName) delete[] CurrentSectionName;
145 CurrentSectionName = copystring(s);
146 SetCurrentTopic(s);
147 }
148 void SetCurrentSubsectionName(char *s)
149 {
150 if (CurrentSubsectionName) delete[] CurrentSubsectionName;
151 CurrentSubsectionName = copystring(s);
152 SetCurrentTopic(s);
153 }
154
155 // Indicate that a parent topic at level 'level' has children.
156 // Level 1 is a chapter, 2 is a section, etc.
157 void NotifyParentHasChildren(int parentLevel)
158 {
159 char *parentTopic = NULL;
160 switch (parentLevel)
161 {
162 case 1:
163 {
164 parentTopic = CurrentChapterName;
165 break;
166 }
167 case 2:
168 {
169 parentTopic = CurrentSectionName;
170 break;
171 }
172 case 3:
173 {
174 parentTopic = CurrentSubsectionName;
175 break;
176 }
177 default:
178 {
179 break;
180 }
181 }
182 if (parentTopic)
183 {
184 TexTopic *texTopic = (TexTopic *)TopicTable.Get(parentTopic);
185 if (!texTopic)
186 {
187 texTopic = new TexTopic;
188 TopicTable.Put(parentTopic, texTopic);
189 }
190 texTopic->hasChildren = TRUE;
191 }
192 }
193
194 // Have to keep a count of what levels are books, what are pages,
195 // in order to correct for a Win95 bug which means that if you
196 // have a book at level n, and then a page at level n, the page
197 // ends up on level n + 1.
198
199 bool ContentsLevels[5];
200
201 // Reset below this level (starts from 1)
202 void ResetContentsLevels(int l)
203 {
204 int i;
205 for (i = l; i < 5; i++)
206 ContentsLevels[i] = FALSE;
207
208 // There are always books on the top level
209 ContentsLevels[0] = TRUE;
210 }
211
212 // Output a WinHelp section as a keyword, substituting
213 // : for space.
214 void OutputSectionKeyword(FILE *fd)
215 {
216 OutputCurrentSectionToString(wxBuffer);
217
218 unsigned int i;
219 for (i = 0; i < strlen(wxBuffer); i++)
220 if (wxBuffer[i] == ':')
221 wxBuffer[i] = ' ';
222 // Don't write to index if there's some RTF in the string
223 else if ( wxBuffer[i] == '{' )
224 return;
225
226 fprintf(fd, "K{\\footnote {K} ");
227 fprintf(fd, "%s", wxBuffer);
228
229 fprintf(fd, "}\n");
230 }
231
232 // Write a line for the .cnt file, if we're doing this.
233 void WriteWinHelpContentsFileLine(char *topicName, char *xitle, int level)
234 {
235 // First, convert any RTF characters to ASCII
236 char title[255];
237 int s=0;
238 int d=0;
239 while ( (xitle[s]!=0)&&(d<255) )
240 {
241 char ch=xitle[s]&0xff;
242 if (ch==0x5c) {
243 char ch1=xitle[s+1]&0xff;
244 char ch2=xitle[s+2]&0xff;
245 char ch3=xitle[s+3]&0xff;
246 char ch4=xitle[s+4]&0xff;
247 s+=4; // next character
248 char a=0;
249 if ((ch1==0x27)&&(ch2==0x66)&&(ch3==0x36)) { title[d++]='ö'; a=1; }
250 if ((ch1==0x27)&&(ch2==0x65)&&(ch3==0x34)) { title[d++]='ä'; a=1; }
251 if ((ch1==0x27)&&(ch2==0x66)&&(ch3==0x63)) { title[d++]='ü'; a=1; }
252 if ((ch1==0x27)&&(ch2==0x64)&&(ch3==0x36)) { title[d++]='Ö'; a=1; }
253 if ((ch1==0x27)&&(ch2==0x63)&&(ch3==0x34)) { title[d++]='Ä'; a=1; }
254 if ((ch1==0x27)&&(ch2==0x64)&&(ch3==0x63)) { title[d++]='Ü'; a=1; }
255 // if (a==0)
256 // printf("!!!!! %04X %04X %04X %04X! \n",ch1,ch2,ch3,ch4);
257 } else {
258 title[d++]=ch;
259 s++;
260 }
261 }
262 title[d]=0;
263
264 // Section (2) becomes level 1 if it's an article.
265 if (DocumentStyle == LATEX_ARTICLE)
266 level --;
267
268 if (level == 0) // Means we had a Chapter in an article, oops.
269 return;
270
271 ResetContentsLevels(level);
272
273 if (!title)
274 return;
275
276 if (winHelp && winHelpContents && WinHelpContentsFile)
277 {
278 TexTopic *texTopic = (TexTopic *)TopicTable.Get(topicName);
279 if (texTopic)
280 {
281 // If a previous section at this level was a book, we *have* to have a
282 // book not a page, because of a bug in WHC (or WinHelp 4).
283 if (texTopic->hasChildren || level == 1 || ContentsLevels[level-1])
284 {
285 // At this level, we have a pointer to a further hierarchy.
286 // So we need a 'book' consisting of (say) Chapter 1.
287 fprintf(WinHelpContentsFile, "%d %s\n", level, title);
288
289 // Then we have a 'page' consisting of the text for this chapter
290 fprintf(WinHelpContentsFile, "%d %s=%s\n", level+1, title, topicName);
291
292 // Then we'll be writing out further pages or books at level + 1...
293
294 // Remember that at this level, we had a book and *must* for the
295 // remainder of sections at this level.
296 ContentsLevels[level-1] = TRUE;
297 }
298 else
299 {
300 fprintf(WinHelpContentsFile, "%d %s=%s\n", level, title, topicName);
301 }
302 }
303 else
304 {
305 if (level == 1 || ContentsLevels[level-1])
306 {
307 // Always have a book at level 1
308 fprintf(WinHelpContentsFile, "%d %s\n", level, title);
309 fprintf(WinHelpContentsFile, "%d %s=%s\n", level+1, title, topicName);
310 ContentsLevels[level-1] = TRUE;
311 }
312 else
313 // Probably doesn't have children if it hasn't been added to the topic table
314 fprintf(WinHelpContentsFile, "%d %s=%s\n", level, title, topicName);
315 }
316 }
317 }
318
319 void SplitIndexEntry(char *entry, char *buf1, char *buf2)
320 {
321 int len = strlen(entry); int i = 0;
322 while ((i < len) && entry[i] != '!')
323 { buf1[i] = entry[i]; i ++; }
324 buf1[i] = 0; buf2[0] = 0; int j = 0;
325
326 if (entry[i] == '!')
327 {
328 i ++;
329 while (i < len) { buf2[j] = entry[i]; i ++; j++; }
330 buf2[j] = 0;
331 }
332 }
333
334 /*
335 * Output topic index entries in WinHelp RTF
336 *
337 */
338 void GenerateKeywordsForTopic(char *topic)
339 {
340 TexTopic *texTopic = (TexTopic *)TopicTable.Get(topic);
341 if (!texTopic)
342 return;
343
344 wxStringList *list = texTopic->keywords;
345 if (list)
346 {
347 wxNode *node = list->First();
348 while (node)
349 {
350 char *s = (char *)node->Data();
351
352 // Must separate out main entry form subentry (only 1 subentry allowed)
353 char buf1[100]; char buf2[100];
354 SplitIndexEntry(s, buf1, buf2);
355
356 // Check for ':' which messes up index
357 unsigned int i;
358 for (i = 0; i < strlen(buf1) ; i++)
359 if (buf1[i] == ':')
360 buf1[i] = ' ';
361 for (i = 0; i < strlen(buf2) ; i++)
362 if (buf2[i] == ':')
363 buf2[i] = ' ';
364
365 // {K} is a strange fix to prevent words beginning with K not
366 // being indexed properly
367 TexOutput("K{\\footnote {K} ");
368 TexOutput(buf1);
369 if (strlen(buf2) > 0)
370 {
371 // Output subentry
372 TexOutput(", ");
373 TexOutput(buf2);
374 }
375 TexOutput("}\n");
376 node = node->Next();
377 }
378 }
379 }
380
381 /*
382 * Output index entry in linear RTF
383 *
384 */
385
386 void GenerateIndexEntry(char *entry)
387 {
388 if (useWord)
389 {
390 char buf1[100]; char buf2[100];
391 SplitIndexEntry(entry, buf1, buf2);
392
393 TexOutput("{\\xe\\v {");
394 TexOutput(buf1);
395 if (strlen(buf2) > 0)
396 {
397 TexOutput("\\:");
398 TexOutput(buf2);
399 }
400 TexOutput("}}");
401 }
402 }
403
404 /*
405 * Write a suitable RTF header.
406 *
407 */
408
409 void WriteColourTable(FILE *fd)
410 {
411 fprintf(fd, "{\\colortbl");
412 wxNode *node = ColourTable.First();
413 while (node)
414 {
415 ColourTableEntry *entry = (ColourTableEntry *)node->Data();
416 fprintf(fd, "\\red%d\\green%d\\blue%d;\n", entry->red, entry->green, entry->blue);
417 node = node->Next();
418 }
419 fprintf(fd, "}");
420 }
421
422 /*
423 * Write heading style
424 *
425 */
426
427 void WriteHeadingStyle(FILE *fd, int heading)
428 {
429 switch (heading)
430 {
431 case 1:
432 {
433 fprintf(fd, "\\b\\fs%d", chapterFont*2);
434 break;
435 }
436 case 2:
437 {
438 fprintf(fd, "\\b\\fs%d", sectionFont*2);
439 break;
440 }
441 case 3:
442 {
443 fprintf(fd, "\\b\\fs%d", subsectionFont*2);
444 break;
445 }
446 case 4:
447 {
448 fprintf(fd, "\\b\\fs%d", subsectionFont*2);
449 break;
450 }
451 default:
452 break;
453 }
454 }
455
456 void WriteRTFHeader(FILE *fd)
457 {
458 fprintf(fd, "{\\rtf1\\%s \\deff0\n", RTFCharset);
459 fprintf(fd, "{\\fonttbl{\\f0\\froman Times New Roman;}{\\f1\\ftech Symbol;}{\\f2\\fswiss Arial;}\n");
460 fprintf(fd, "{\\f3\\fmodern Courier;}{\\f4\\ftech Wingdings;}{\\f5\\ftech Monotype Sorts;}\n}");
461 /*
462 * Style sheet
463 */
464 fprintf(fd, "{\\stylesheet{\\f2\\fs20 \\snext0 Normal;}\n");
465 // Headings
466 fprintf(fd, "{\\s1 "); WriteHeadingStyle(fd, 1); fprintf(fd, "\\sbasedon0\\snext0 heading 1;}\n");
467 fprintf(fd, "{\\s2 "); WriteHeadingStyle(fd, 2); fprintf(fd, "\\sbasedon0\\snext0 heading 2;}\n");
468 fprintf(fd, "{\\s3 "); WriteHeadingStyle(fd, 3); fprintf(fd, "\\sbasedon0\\snext0 heading 3;}\n");
469 fprintf(fd, "{\\s4 "); WriteHeadingStyle(fd, 4); fprintf(fd, "\\sbasedon0\\snext0 heading 4;}\n");
470 // Table of contents styles
471 fprintf(fd, "{\\s20\\sb300\\tqr\\tldot\\tx8640 \\b\\f2 \\sbasedon0\\snext0 toc 1;}\n");
472
473 fprintf(fd, "{\\s21\\sb90\\tqr\\tldot\\li400\\tqr\\tx8640 \\f2\\fs20\\sbasedon0\\snext0 toc 2;}\n");
474 fprintf(fd, "{\\s22\\sb90\\tqr\\tldot\\li800\\tx8640 \\f2\\fs20 \\sbasedon0\\snext0 toc 3;}\n");
475 fprintf(fd, "{\\s23\\sb90\\tqr\\tldot\\li1200\\tx8640 \\f2\\fs20 \\sbasedon0\\snext0 toc 4;}\n");
476
477 // Index styles
478 fprintf(fd, "{\\s30\\fi-200\\li200\\tqr\\tx3960 \\f2\\fs18 \\sbasedon0\\snext0 index 1;}\n");
479 fprintf(fd, "{\\s31\\fi-200\\li400\\tqr\\tx3960 \\f2\\fs18 \\sbasedon0\\snext0 index 2;}\n");
480 fprintf(fd, "{\\s32\\fi-200\\li600\\tqr\\tx3960 \\f2\\fs18 \\sbasedon0\\snext0 index 3;}\n");
481 fprintf(fd, "{\\s33\\fi-200\\li800\\tqr\\tx3960 \\f2\\fs18 \\sbasedon0\\snext0 index 4;}\n");
482 fprintf(fd, "{\\s35\\qc\\sb240\\sa120 \\b\\f2\\fs26 \\sbasedon0\\snext30 index heading;}\n");
483 fprintf(fd, "}\n");
484
485 WriteColourTable(fd);
486 fprintf(fd, "\n\\ftnbj\\ftnrestart"); // Latex default is footnotes at bottom of page, not section.
487 fprintf(fd, "\n");
488 }
489
490 void OutputNumberStyle(char *numberStyle)
491 {
492 if (numberStyle)
493 {
494 if (strcmp(numberStyle, "arabic") == 0)
495 {
496 TexOutput("\\pgndec");
497 }
498 else if (strcmp(numberStyle, "roman") == 0)
499 {
500 TexOutput("\\pgnlcrm");
501 }
502 else if (strcmp(numberStyle, "Roman") == 0)
503 {
504 TexOutput("\\pgnucrm");
505 }
506 else if (strcmp(numberStyle, "alph") == 0)
507 {
508 TexOutput("\\pgnlcltr");
509 }
510 else if (strcmp(numberStyle, "Alph") == 0)
511 {
512 TexOutput("\\pgnucltr");
513 }
514 }
515 }
516
517 /*
518 * Write a Windows help project file
519 */
520
521 bool WriteHPJ(char *filename)
522 {
523 char hpjFilename[256];
524 char helpFile[50];
525 char rtfFile[50];
526 strcpy(hpjFilename, filename);
527 StripExtension(hpjFilename);
528 strcat(hpjFilename, ".hpj");
529
530 strcpy(helpFile, FileNameFromPath(filename));
531 StripExtension(helpFile);
532 strcpy(rtfFile, helpFile);
533 strcat(helpFile, ".hlp");
534 strcat(rtfFile, ".rtf");
535
536 FILE *fd = fopen(hpjFilename, "w");
537 if (!fd)
538 return FALSE;
539
540 char *helpTitle = winHelpTitle;
541 if (!helpTitle)
542 helpTitle = "Untitled";
543
544 wxString thePath = wxPathOnly(InputFile);
545 if (thePath.IsEmpty())
546 thePath = ".";
547 fprintf(fd, "[OPTIONS]\n");
548 fprintf(fd, "BMROOT=%s ; Assume that bitmaps are where the source is\n", thePath.c_str());
549 fprintf(fd, "TITLE=%s\n", helpTitle);
550 fprintf(fd, "CONTENTS=Contents\n");
551
552 if (winHelpVersion > 3)
553 {
554 fprintf(fd, "; COMPRESS=12 Hall Zeck ; Max compression, but needs lots of memory\n");
555 fprintf(fd, "COMPRESS=8 Zeck\n");
556 fprintf(fd, "LCID=0x809 0x0 0x0 ;English (British)\n");
557 fprintf(fd, "HLP=.\\%s.hlp\n", wxFileNameFromPath(FileRoot));
558 }
559 else
560 {
561 fprintf(fd, "COMPRESS=HIGH\n");
562 }
563 fprintf(fd, "\n");
564
565 if (winHelpVersion > 3)
566 {
567 fprintf(fd, "[WINDOWS]\n");
568 fprintf(fd, "Main=\"\",(553,102,400,600),20736,(r14876671),(r12632256),f3\n");
569 fprintf(fd, "\n");
570 }
571
572 fprintf(fd, "[FILES]\n%s\n\n", rtfFile);
573 fprintf(fd, "[CONFIG]\n");
574 if (useUpButton)
575 fprintf(fd, "CreateButton(\"Up\", \"&Up\", \"JumpId(`%s', `Contents')\")\n", helpFile);
576 fprintf(fd, "BrowseButtons()\n\n");
577 fprintf(fd, "[MAP]\n\n[BITMAPS]\n\n");
578 fclose(fd);
579 return TRUE;
580 }
581
582
583 /*
584 * Given a TexChunk with a string value, scans through the string
585 * converting Latex-isms into RTF-isms, such as 2 newlines -> \par,
586 * and inserting spaces at the start of lines since in Latex, a newline
587 * implies a space, but not in RTF.
588 *
589 */
590
591 void ProcessText2RTF(TexChunk *chunk)
592 {
593 bool changed = FALSE;
594 int ptr = 0;
595 int i = 0;
596 char ch = 1;
597 int len = strlen(chunk->value);
598 while (ch != 0)
599 {
600 ch = chunk->value[i];
601
602 if (ch == 10)
603 {
604 if (inVerbatim)
605 {
606 BigBuffer[ptr] = 0; strcat(BigBuffer, "\\par\n"); ptr += 5;
607 i ++;
608 changed = TRUE;
609 }
610 else
611 {
612 // If the first character of the next line is ASCII,
613 // put a space in. Implicit in Latex, not in RTF.
614 /*
615 The reason this is difficult is that you don't really know
616 where a space would be appropriate. If you always put in a space
617 when you find a newline, unwanted spaces appear in the text.
618 */
619 if ((i > 0) && (len > i+1 && isascii(chunk->value[i+1]) &&
620 !isspace(chunk->value[i+1])) ||
621 ((len > i+1 && chunk->value[i+1] == 13) &&
622 (len > i+2 && isascii(chunk->value[i+2]) &&
623 !isspace(chunk->value[i+2]))))
624 // if (TRUE)
625 {
626 // DOS files have a 13 after the 10
627 BigBuffer[ptr] = 10;
628 ptr ++;
629 i ++;
630 if (chunk->value[i] == 13)
631 {
632 BigBuffer[ptr] = 13;
633 ptr ++;
634 i ++;
635 }
636
637 BigBuffer[ptr] = ' ';
638 ptr ++;
639
640 // Note that the actual ASCII character seen is dealt with in the next
641 // iteration
642 changed = TRUE;
643 }
644 else
645 {
646 BigBuffer[ptr] = ch;
647 i ++;
648 }
649 }
650 }
651 else if (!inVerbatim && ch == '`' && (len >= i+1 && chunk->value[i+1] == '`'))
652 {
653 BigBuffer[ptr] = '"'; ptr ++;
654 i += 2;
655 changed = TRUE;
656 }
657 else if (!inVerbatim && ch == '`') // Change ` to '
658 {
659 BigBuffer[ptr] = 39; ptr ++;
660 i += 1;
661 changed = TRUE;
662 }
663 else if (inVerbatim && ch == '\\') // Change backslash to two backslashes
664 {
665 BigBuffer[ptr] = '\\'; ptr ++;
666 BigBuffer[ptr] = '\\'; ptr ++;
667 i += 1;
668 changed = TRUE;
669 }
670 else if (inVerbatim && (ch == '{' || ch == '}')) // Escape the curley bracket
671 {
672 BigBuffer[ptr] = '\\'; ptr ++;
673 BigBuffer[ptr] = ch; ptr ++;
674 i += 1;
675 changed = TRUE;
676 }
677 else
678 {
679 BigBuffer[ptr] = ch;
680 i ++;
681 ptr ++;
682 }
683 }
684 BigBuffer[ptr] = 0;
685
686 if (changed)
687 {
688 delete[] chunk->value;
689 chunk->value = copystring(BigBuffer);
690 }
691 }
692
693 /*
694 * Scan through all chunks starting from the given one,
695 * calling ProcessText2RTF to convert Latex-isms to RTF-isms.
696 * This should be called after Tex2Any has parsed the file,
697 * and before TraverseDocument is called.
698 *
699 */
700
701 void Text2RTF(TexChunk *chunk)
702 {
703 Tex2RTFYield();
704 if (stopRunning) return;
705
706 switch (chunk->type)
707 {
708 case CHUNK_TYPE_MACRO:
709 {
710 TexMacroDef *def = chunk->def;
711 if (def && def->ignore)
712 return;
713
714 if (def && (def->macroId == ltVERBATIM || def->macroId == ltVERB))
715 inVerbatim = TRUE;
716
717 wxNode *node = chunk->children.First();
718 while (node)
719 {
720 TexChunk *child_chunk = (TexChunk *)node->Data();
721 Text2RTF(child_chunk);
722 node = node->Next();
723 }
724
725 if (def && (def->macroId == ltVERBATIM || def->macroId == ltVERB))
726 inVerbatim = FALSE;
727
728 break;
729 }
730 case CHUNK_TYPE_ARG:
731 {
732 wxNode *node = chunk->children.First();
733 while (node)
734 {
735 TexChunk *child_chunk = (TexChunk *)node->Data();
736 Text2RTF(child_chunk);
737 node = node->Next();
738 }
739
740 break;
741 }
742 case CHUNK_TYPE_STRING:
743 {
744 if (chunk->value)
745 ProcessText2RTF(chunk);
746 break;
747 }
748 }
749 }
750
751 /*
752 * Not used yet
753 *
754 */
755
756 char browseBuf[10];
757 static long browseId = 0;
758 char *GetBrowseString(void)
759 {
760 char buf[10];
761 browseId ++;
762 sprintf(buf, "%ld", browseId);
763 int noZeroes = 5-strlen(buf);
764 strcpy(browseBuf, "browse");
765 for (int i = 0; i < noZeroes; i++)
766 strcat(browseBuf, "0");
767 strcat(browseBuf, buf);
768 return browseBuf;
769 }
770
771 /*
772 * Keeping track of environments to restore the styles after \pard.
773 * Push strings like "\qc" onto stack.
774 *
775 */
776
777 void PushEnvironmentStyle(char *style)
778 {
779 environmentStack.Add(style);
780 }
781
782 void PopEnvironmentStyle(void)
783 {
784 wxNode *node = environmentStack.Last();
785 if (node)
786 {
787 char *val = (char *)node->Data();
788 delete[] val;
789 delete node;
790 }
791 }
792
793 // Write out the styles, most recent first.
794 void WriteEnvironmentStyles(void)
795 {
796 wxNode *node = environmentStack.Last();
797 while (node)
798 {
799 char *val = (char *)node->Data();
800 TexOutput(val);
801 node = node->Next();
802 }
803 if (!inTabular && (ParIndent > 0) && (forbidParindent == 0))
804 {
805 char buf[15];
806 sprintf(buf, "\\fi%d", ParIndent*20); // Convert points to TWIPS
807 TexOutput(buf);
808 }
809 if (environmentStack.Number() > 0 || (ParIndent > 0))
810 TexOutput("\n");
811 }
812
813
814 /*
815 * Output a header
816 *
817 */
818
819 void OutputRTFHeaderCommands(void)
820 {
821 char buf[300];
822 if (PageStyle && strcmp(PageStyle, "plain") == 0)
823 {
824 TexOutput("{\\headerl }{\\headerr }");
825 }
826 else if (PageStyle && strcmp(PageStyle, "empty") == 0)
827 {
828 TexOutput("{\\headerl }{\\headerr }");
829 }
830 else if (PageStyle && strcmp(PageStyle, "headings") == 0)
831 {
832 // Left header
833 TexOutput("{\\headerl\\fi0 ");
834
835 if (headerRule)
836 TexOutput("\\brdrb\\brdrs\\brdrw15\\brsp20 ");
837
838 TexOutput("{\\i \\qr ");
839 if (DocumentStyle == LATEX_ARTICLE)
840 {
841 sprintf(buf, "SECTION %d", sectionNo);
842 TexOutput(buf);
843 }
844 else
845 {
846 sprintf(buf, "CHAPTER %d: ", chapterNo);
847 TexOutput(buf);
848 }
849 TexOutput("{\\field{\\*\\fldinst PAGE \\\\* MERGEFORMAT }{\\fldrslt 1}}");
850 TexOutput("}\\par\\pard}");
851
852 // Right header
853 TexOutput("{\\headerr\\fi0 ");
854
855 if (headerRule)
856 TexOutput("\\brdrb\\brdrs\\brdrw15\\brsp20 ");
857
858 TexOutput("{\\i \\qc ");
859 if (DocumentStyle == LATEX_ARTICLE)
860 {
861 sprintf(buf, "SECTION %d", sectionNo);
862 TexOutput(buf);
863 }
864 else
865 {
866 sprintf(buf, "CHAPTER %d", chapterNo);
867 TexOutput(buf);
868 }
869 TexOutput("{\\field{\\*\\fldinst PAGE \\\\* MERGEFORMAT }{\\fldrslt 1}}");
870 TexOutput("}\\par\\pard}");
871 }
872 else
873 {
874 int oldForbidResetPar = forbidResetPar;
875 forbidResetPar = 0;
876
877 if (LeftHeaderEven || CentreHeaderEven || RightHeaderEven)
878 {
879 TexOutput("{\\headerl\\fi0 ");
880
881 if (headerRule)
882 TexOutput("\\brdrb\\brdrs\\brdrw15\\brsp20 ");
883
884 if (LeftHeaderEven)
885 {
886 if (!CentreHeaderEven && !RightHeaderEven)
887 TexOutput("\\ql ");
888 TraverseChildrenFromChunk(LeftHeaderEven);
889 }
890 if (CentreHeaderEven)
891 {
892 if (!LeftHeaderEven && !RightHeaderEven)
893 TexOutput("\\qc ");
894 else
895 TexOutput("\\tab\\tab\\tab ");
896 TraverseChildrenFromChunk(CentreHeaderEven);
897 }
898 if (RightHeaderEven)
899 {
900 if (!LeftHeaderEven && !CentreHeaderEven)
901 TexOutput("\\qr ");
902 else
903 TexOutput("\\tab\\tab\\tab\\tab\\tab\\tab ");
904 TraverseChildrenFromChunk(RightHeaderEven);
905 }
906 TexOutput("\\par\\pard}");
907 }
908
909 if (LeftHeaderOdd || CentreHeaderOdd || RightHeaderOdd)
910 {
911 TexOutput("{\\headerr\\fi0 ");
912
913 if (headerRule)
914 TexOutput("\\brdrb\\brdrs\\brdrw15\\brsp20 ");
915
916 if (LeftHeaderOdd)
917 {
918 if (!CentreHeaderOdd && !RightHeaderOdd)
919 TexOutput("\\ql ");
920 TraverseChildrenFromChunk(LeftHeaderOdd);
921 }
922 if (CentreHeaderOdd)
923 {
924 if (!LeftHeaderOdd && !RightHeaderOdd)
925 TexOutput("\\qc ");
926 else
927 TexOutput("\\tab\\tab\\tab ");
928 TraverseChildrenFromChunk(CentreHeaderOdd);
929 }
930 if (RightHeaderOdd)
931 {
932 if (!LeftHeaderOdd && !CentreHeaderOdd)
933 TexOutput("\\qr ");
934 else
935 TexOutput("\\tab\\tab\\tab\\tab\\tab\\tab ");
936 TraverseChildrenFromChunk(RightHeaderOdd);
937 }
938 TexOutput("\\par\\pard}");
939 }
940 // As an approximation, don't put a header on the first page of a section.
941 // This may not always be desired, but it's a reasonable guess.
942 TexOutput("{\\headerf }");
943
944 forbidResetPar = oldForbidResetPar;
945 }
946 }
947
948 void OutputRTFFooterCommands(void)
949 {
950 if (PageStyle && strcmp(PageStyle, "plain") == 0)
951 {
952 TexOutput("{\\footerl\\fi0 ");
953 if (footerRule)
954 TexOutput("\\brdrt\\brdrs\\brdrw15\\brsp20 ");
955 TexOutput("{\\qc ");
956 TexOutput("{\\field{\\*\\fldinst PAGE \\\\* MERGEFORMAT }{\\fldrslt 1}}");
957 TexOutput("}\\par\\pard}");
958
959 TexOutput("{\\footerr\\fi0 ");
960 if (footerRule)
961 TexOutput("\\brdrt\\brdrs\\brdrw15\\brsp20 ");
962 TexOutput("{\\qc ");
963 TexOutput("{\\field{\\*\\fldinst PAGE \\\\* MERGEFORMAT }{\\fldrslt 1}}");
964 TexOutput("}\\par\\pard}");
965 }
966 else if (PageStyle && strcmp(PageStyle, "empty") == 0)
967 {
968 TexOutput("{\\footerl }{\\footerr }");
969 }
970 else if (PageStyle && strcmp(PageStyle, "headings") == 0)
971 {
972 TexOutput("{\\footerl }{\\footerr }");
973 }
974 else
975 {
976 if (LeftFooterEven || CentreFooterEven || RightFooterEven)
977 {
978 TexOutput("{\\footerl\\fi0 ");
979 if (footerRule)
980 TexOutput("\\brdrt\\brdrs\\brdrw15\\brsp20 ");
981 if (LeftFooterEven)
982 {
983 if (!CentreFooterEven && !RightFooterEven)
984 TexOutput("\\ql ");
985 TraverseChildrenFromChunk(LeftFooterEven);
986 }
987 if (CentreFooterEven)
988 {
989 if (!LeftFooterEven && !RightFooterEven)
990 TexOutput("\\qc ");
991 else
992 TexOutput("\\tab\\tab\\tab ");
993 TraverseChildrenFromChunk(CentreFooterEven);
994 }
995 if (RightFooterEven)
996 {
997 if (!LeftFooterEven && !CentreFooterEven)
998 TexOutput("\\qr ");
999 else
1000 TexOutput("\\tab\\tab\\tab\\tab\\tab\\tab ");
1001 TraverseChildrenFromChunk(RightFooterEven);
1002 }
1003 TexOutput("\\par\\pard}");
1004 }
1005
1006 if (LeftFooterOdd || CentreFooterOdd || RightFooterOdd)
1007 {
1008 TexOutput("{\\footerr\\fi0 ");
1009 if (footerRule)
1010 TexOutput("\\brdrt\\brdrs\\brdrw15\\brsp20 ");
1011 if (LeftFooterOdd)
1012 {
1013 if (!CentreFooterOdd && !RightFooterOdd)
1014 TexOutput("\\ql ");
1015 TraverseChildrenFromChunk(LeftFooterOdd);
1016 }
1017 if (CentreFooterOdd)
1018 {
1019 if (!LeftFooterOdd && !RightFooterOdd)
1020 TexOutput("\\qc ");
1021 else
1022 TexOutput("\\tab\\tab\\tab ");
1023 TraverseChildrenFromChunk(CentreFooterOdd);
1024 }
1025 if (RightFooterOdd)
1026 {
1027 if (!LeftFooterOdd && !CentreFooterOdd)
1028 TexOutput("\\qr ");
1029 else
1030 TexOutput("\\tab\\tab\\tab\\tab\\tab\\tab ");
1031 TraverseChildrenFromChunk(RightFooterOdd);
1032 }
1033 TexOutput("\\par\\pard}");
1034 }
1035
1036 // As an approximation, put a footer on the first page of a section.
1037 // This may not always be desired, but it's a reasonable guess.
1038 if (LeftFooterOdd || CentreFooterOdd || RightFooterOdd)
1039 {
1040 TexOutput("{\\footerf\\fi0 ");
1041 if (LeftFooterOdd)
1042 {
1043 if (!CentreFooterOdd && !RightFooterOdd)
1044 TexOutput("\\ql ");
1045 TraverseChildrenFromChunk(LeftFooterOdd);
1046 }
1047 if (CentreFooterOdd)
1048 {
1049 if (!LeftFooterOdd && !RightFooterOdd)
1050 TexOutput("\\qc ");
1051 else
1052 TexOutput("\\tab\\tab\\tab ");
1053 TraverseChildrenFromChunk(CentreFooterOdd);
1054 }
1055 if (RightFooterOdd)
1056 {
1057 if (!LeftFooterOdd && !CentreFooterOdd)
1058 TexOutput("\\qr ");
1059 else
1060 TexOutput("\\tab\\tab\\tab\\tab\\tab\\tab ");
1061 TraverseChildrenFromChunk(RightFooterOdd);
1062 }
1063 TexOutput("\\par\\pard}");
1064 }
1065 }
1066 }
1067
1068 // Called on start/end of macro examination
1069 void RTFOnMacro(int macroId, int no_args, bool start)
1070 {
1071 /*
1072 char tmpBuf[40];
1073 sprintf(tmpBuf, "%d (%d)", macroId, (int)start);
1074 OutputDebugString("RTFOnMacro Start "); OutputDebugString(tmpBuf);
1075 OutputDebugString("\n"); wxYield();
1076 */
1077
1078 // ltLABEL is included here because after a section but BEFORE
1079 // the label is seen, a new paragraph is issued. Don't upset this by
1080 // immediately forgetting we've done it.
1081 if (start && (macroId != ltPAR && macroId != ltITEMIZE &&
1082 macroId != ltENUMERATE && macroId != ltDESCRIPTION &&
1083 macroId != ltVERBATIM && macroId != ltLABEL &&
1084 macroId != ltSETHEADER && macroId != ltSETFOOTER &&
1085 macroId != ltPAGENUMBERING &&
1086 (forbidResetPar == 0)))
1087 {
1088 issuedNewParagraph = 0;
1089 }
1090
1091 char buf[300];
1092 switch (macroId)
1093 {
1094 case ltCHAPTER:
1095 case ltCHAPTERSTAR:
1096 case ltCHAPTERHEADING:
1097 case ltCHAPTERHEADINGSTAR:
1098 {
1099 if (!start)
1100 {
1101 sectionNo = 0;
1102 figureNo = 0;
1103 tableNo = 0;
1104 subsectionNo = 0;
1105 subsubsectionNo = 0;
1106 footnoteCount = 0;
1107
1108 if (macroId != ltCHAPTERSTAR && macroId != ltCHAPTERHEADINGSTAR)
1109 chapterNo ++;
1110
1111 char *topicName = FindTopicName(GetNextChunk());
1112 SetCurrentChapterName(topicName);
1113
1114 if (winHelpContents && winHelp && !InPopups())
1115 {
1116 OutputCurrentSectionToString(wxBuffer);
1117 WriteWinHelpContentsFileLine(topicName, wxBuffer, 1);
1118 }
1119 AddTexRef(topicName, NULL, ChapterNameString, chapterNo);
1120
1121 if (winHelp)
1122 {
1123 if (!InPopups())
1124 fprintf(Contents, "\n{\\uldb ");
1125 fprintf(Chapters, "\\page");
1126 fprintf(Chapters, "\n${\\footnote ");
1127 if (!InPopups())
1128 SetCurrentOutputs(Contents, Chapters);
1129 else
1130 SetCurrentOutput(Chapters);
1131 }
1132 else
1133 {
1134 fprintf(Chapters, "\\sect\\pgncont\\titlepg\n");
1135
1136 // If a non-custom page style, we generate the header now.
1137 if (PageStyle && (strcmp(PageStyle, "plain") == 0 ||
1138 strcmp(PageStyle, "empty") == 0 ||
1139 strcmp(PageStyle, "headings") == 0))
1140 {
1141 OutputRTFHeaderCommands();
1142 OutputRTFFooterCommands();
1143 }
1144
1145 // Need to reset the current numbering style, or RTF forgets it.
1146 SetCurrentOutput(Chapters);
1147 OutputNumberStyle(currentNumberStyle);
1148
1149 SetCurrentOutput(Contents);
1150
1151 if (!InPopups())
1152 {
1153 if (macroId == ltCHAPTER)
1154 {
1155 // Section
1156 fprintf(Contents, "\\par\n\\pard{\\b %d\\tab ", chapterNo);
1157 }
1158 else if (macroId == ltCHAPTERHEADING)
1159 {
1160 fprintf(Contents, "\\par\n\\pard{\\b ");
1161 }
1162 else SetCurrentOutput(NULL); // No entry in table of contents
1163 }
1164 }
1165
1166 startedSections = TRUE;
1167
1168 // Output heading to contents page
1169 if (!InPopups())
1170 {
1171 OutputCurrentSection();
1172
1173 if (winHelp)
1174 fprintf(Contents, "}{\\v %s}\\par\\pard\n", topicName);
1175 else if ((macroId == ltCHAPTER) || (macroId == ltCHAPTERHEADING))
1176 fprintf(Contents, "}\\par\\par\\pard\n");
1177
1178 // From here, just output to chapter
1179 SetCurrentOutput(Chapters);
1180 }
1181
1182 if (winHelp)
1183 {
1184 fprintf(Chapters, "}\n#{\\footnote %s}\n", topicName);
1185 fprintf(Chapters, "+{\\footnote %s}\n", GetBrowseString());
1186
1187 OutputSectionKeyword(Chapters);
1188
1189 GenerateKeywordsForTopic(topicName);
1190 if (useUpButton)
1191 {
1192 // If we're generating a .cnt file, we don't want to be able
1193 // jump up to the old-style contents page, so disable it.
1194 if (winHelpContents)
1195 fprintf(Chapters, "!{\\footnote DisableButton(\"Up\")}\n");
1196 else
1197 fprintf(Chapters, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
1198 FileNameFromPath(FileRoot), "Contents");
1199 }
1200 }
1201
1202 if (!InPopups())
1203 {
1204 char *styleCommand = "";
1205 if (!winHelp && useHeadingStyles && (macroId == ltCHAPTER || macroId == ltCHAPTERHEADING || macroId == ltCHAPTERHEADINGSTAR))
1206 styleCommand = "\\s1";
1207 fprintf(Chapters, "\\pard{%s", ((winHelp && !InPopups()) ? "\\keepn\\sa140\\sb140" : styleCommand));
1208 WriteHeadingStyle(Chapters, 1); fprintf(Chapters, " ");
1209 if (!winHelp)
1210 {
1211 if (macroId == ltCHAPTER)
1212 {
1213 if (useWord)
1214 // fprintf(Chapters, "{\\bkmkstart %s}%d{\\bkmkend %s}. ", topicName, chapterNo,
1215 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName, topicName);
1216 else
1217 fprintf(Chapters, "%d. ", chapterNo);
1218 }
1219 else if ( useWord )
1220 {
1221 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName, topicName);
1222 }
1223 }
1224 OutputCurrentSection();
1225 TexOutput("\\par\\pard}\\par\n");
1226 }
1227 issuedNewParagraph = 2;
1228 }
1229 break;
1230 }
1231 case ltSECTION:
1232 case ltSECTIONSTAR:
1233 case ltSECTIONHEADING:
1234 case ltSECTIONHEADINGSTAR:
1235 case ltGLOSS:
1236 {
1237 FILE *jumpFrom;
1238 if (DocumentStyle == LATEX_ARTICLE)
1239 jumpFrom = Contents;
1240 else
1241 jumpFrom = Chapters;
1242
1243 if (!start)
1244 {
1245 subsectionNo = 0;
1246 subsubsectionNo = 0;
1247 if (DocumentStyle == LATEX_ARTICLE)
1248 footnoteCount = 0;
1249
1250 if (macroId != ltSECTIONSTAR && macroId != ltSECTIONHEADINGSTAR)
1251 sectionNo ++;
1252
1253 char *topicName = FindTopicName(GetNextChunk());
1254 SetCurrentSectionName(topicName);
1255 NotifyParentHasChildren(1);
1256 if (winHelpContents && winHelp && !InPopups())
1257 {
1258 OutputCurrentSectionToString(wxBuffer);
1259 WriteWinHelpContentsFileLine(topicName, wxBuffer, 2);
1260 }
1261 AddTexRef(topicName, NULL, SectionNameString, chapterNo, sectionNo);
1262
1263 if (winHelp)
1264 {
1265 SetCurrentOutputs(jumpFrom, Sections);
1266 // Newline for a new section if this is an article
1267 if ((DocumentStyle == LATEX_ARTICLE) &&
1268 ((macroId == ltSECTION) || (macroId == ltSECTIONSTAR) || (macroId == ltSECTIONHEADINGSTAR)))
1269 fprintf(Sections, "\\page\n");
1270
1271 if (!InPopups())
1272 fprintf(jumpFrom, "\n{\\uldb ");
1273 }
1274 else
1275 {
1276 if (DocumentStyle == LATEX_ARTICLE)
1277 {
1278 TexOutput("\\sect\\pgncont\n");
1279 // If a non-custom page style, we generate the header now.
1280 if (PageStyle && (strcmp(PageStyle, "plain") == 0 ||
1281 strcmp(PageStyle, "empty") == 0 ||
1282 strcmp(PageStyle, "headings") == 0))
1283 {
1284 OutputRTFHeaderCommands();
1285 OutputRTFFooterCommands();
1286 }
1287 }
1288 SetCurrentOutput(Contents);
1289
1290 if (macroId == ltSECTION)
1291 {
1292 if (!InPopups())
1293 {
1294 if (DocumentStyle == LATEX_REPORT)
1295 fprintf(Contents, "\n\\pard{\\tab %d.%d\\tab ", chapterNo, sectionNo);
1296 else
1297 fprintf(Contents, "\\par\n\\pard{\\b %d\\tab ", sectionNo);
1298 }
1299 }
1300 else if (macroId == ltSECTIONHEADING)
1301 {
1302 if (!InPopups())
1303 {
1304 if (DocumentStyle == LATEX_REPORT)
1305 fprintf(Contents, "\n\\pard{\\tab "); //, chapterNo, sectionNo);
1306 else
1307 fprintf(Contents, "\\par\n\\pard{\\b "); //, sectionNo);
1308 }
1309 }
1310 else SetCurrentOutput(NULL);
1311 }
1312
1313 if (startedSections)
1314 {
1315 if (winHelp)
1316 fprintf(Sections, "\\page\n");
1317 }
1318 startedSections = TRUE;
1319
1320 if (winHelp)
1321 fprintf(Sections, "\n${\\footnote ");
1322
1323 // Output heading to contents page
1324 if (!InPopups())
1325 OutputCurrentSection();
1326
1327 if (winHelp)
1328 {
1329 if (!InPopups())
1330 fprintf(jumpFrom, "}{\\v %s}\\par\\pard\n", topicName);
1331 }
1332 else if ((macroId != ltSECTIONSTAR) && (macroId != ltGLOSS))
1333 {
1334 if (DocumentStyle == LATEX_REPORT)
1335 fprintf(Contents, "}\\par\\pard\n");
1336 else
1337 fprintf(Contents, "}\\par\\par\\pard\n");
1338 }
1339
1340 SetCurrentOutput(winHelp ? Sections : Chapters);
1341
1342 if (winHelp)
1343 {
1344 fprintf(Sections, "}\n#{\\footnote %s}\n", topicName);
1345 fprintf(Sections, "+{\\footnote %s}\n", GetBrowseString());
1346 OutputSectionKeyword(Sections);
1347 GenerateKeywordsForTopic(topicName);
1348 if (useUpButton)
1349 {
1350 if (DocumentStyle == LATEX_ARTICLE)
1351 {
1352 fprintf(Sections, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
1353 FileNameFromPath(FileRoot), "Contents");
1354 }
1355 else if (CurrentChapterName)
1356 {
1357 fprintf(Sections, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
1358 FileNameFromPath(FileRoot), CurrentChapterName);
1359 }
1360 }
1361 }
1362
1363 if (!InPopups())
1364 {
1365 char *styleCommand = "";
1366 if (!winHelp && useHeadingStyles && (macroId != ltSECTIONSTAR))
1367 {
1368 if (DocumentStyle == LATEX_ARTICLE)
1369 styleCommand = "\\s1";
1370 else
1371 styleCommand = "\\s2";
1372 }
1373 char *keep = "";
1374 if (winHelp && (macroId != ltGLOSS) && !InPopups())
1375 keep = "\\keepn\\sa140\\sb140";
1376
1377 fprintf(winHelp ? Sections : Chapters, "\\pard{%s%s",
1378 keep, styleCommand);
1379
1380 WriteHeadingStyle((winHelp ? Sections : Chapters),
1381 (DocumentStyle == LATEX_ARTICLE ? 1 : 2));
1382 fprintf(winHelp ? Sections : Chapters, " ");
1383
1384 if (!winHelp)
1385 {
1386 if ((macroId != ltSECTIONSTAR) && (macroId != ltSECTIONHEADINGSTAR) && (macroId != ltGLOSS))
1387 {
1388 if (DocumentStyle == LATEX_REPORT)
1389 {
1390 if (useWord)
1391 // fprintf(Chapters, "{\\bkmkstart %s}%d.%d{\\bkmkend %s}. ", topicName, chapterNo, sectionNo,
1392 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1393 topicName);
1394 else
1395 fprintf(Chapters, "%d.%d. ", chapterNo, sectionNo);
1396 }
1397 else
1398 {
1399 if (useWord)
1400 // fprintf(Chapters, "{\\bkmkstart %s}%d{\\bkmkend %s}. ", topicName, sectionNo,
1401 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1402 topicName);
1403 else
1404 fprintf(Chapters, "%d. ", sectionNo);
1405 }
1406 }
1407 else if ( useWord )
1408 {
1409 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName, topicName);
1410 }
1411 }
1412 OutputCurrentSection();
1413 TexOutput("\\par\\pard}\\par\n");
1414 }
1415 issuedNewParagraph = 2;
1416 }
1417 break;
1418 }
1419 case ltSUBSECTION:
1420 case ltSUBSECTIONSTAR:
1421 case ltMEMBERSECTION:
1422 case ltFUNCTIONSECTION:
1423 {
1424 if (!start)
1425 {
1426 if (winHelp && !Sections)
1427 {
1428 OnError("You cannot have a subsection before a section!");
1429 }
1430 else
1431 {
1432 subsubsectionNo = 0;
1433
1434 if (macroId != ltSUBSECTIONSTAR)
1435 subsectionNo ++;
1436
1437 char *topicName = FindTopicName(GetNextChunk());
1438 SetCurrentSubsectionName(topicName);
1439 NotifyParentHasChildren(2);
1440 if (winHelpContents && winHelp && !InPopups())
1441 {
1442 OutputCurrentSectionToString(wxBuffer);
1443 WriteWinHelpContentsFileLine(topicName, wxBuffer, 3);
1444 }
1445 AddTexRef(topicName, NULL, SectionNameString, chapterNo, sectionNo, subsectionNo);
1446
1447 if (winHelp)
1448 {
1449 SetCurrentOutputs(Sections, Subsections);
1450 SetCurrentOutputs(Sections, Subsections);
1451 if (!InPopups())
1452 fprintf(Sections, "\n{\\uldb ");
1453 }
1454 else
1455 {
1456 if ((macroId != ltSUBSECTIONSTAR) && (macroId != ltMEMBERSECTION) &&
1457 (macroId != ltFUNCTIONSECTION))
1458 {
1459 SetCurrentOutput(Contents);
1460 if (DocumentStyle == LATEX_REPORT)
1461 fprintf(Contents, "\n\\pard\\tab\\tab %d.%d.%d\\tab ", chapterNo, sectionNo, subsectionNo);
1462 else
1463 fprintf(Contents, "\n\\pard\\tab %d.%d\\tab ", sectionNo, subsectionNo);
1464 } else SetCurrentOutput(NULL);
1465 }
1466 if (startedSections)
1467 {
1468 if (winHelp)
1469 {
1470 if (!InPopups())
1471 fprintf(Subsections, "\\page\n");
1472 }
1473 else
1474 fprintf(Chapters, "\\par\n");
1475 }
1476 startedSections = TRUE;
1477
1478 if (winHelp)
1479 fprintf(Subsections, "\n${\\footnote ");
1480
1481 // Output to contents page
1482 if (!InPopups())
1483 OutputCurrentSection();
1484
1485 if (winHelp)
1486 {
1487 if (!InPopups())
1488 fprintf(Sections, "}{\\v %s}\\par\\pard\n", topicName);
1489 }
1490 else if ((macroId != ltSUBSECTIONSTAR) && (macroId != ltMEMBERSECTION) &&
1491 (macroId != ltFUNCTIONSECTION))
1492 fprintf(Contents, "\\par\\pard\n");
1493
1494 SetCurrentOutput(winHelp ? Subsections : Chapters);
1495 if (winHelp)
1496 {
1497 fprintf(Subsections, "}\n#{\\footnote %s}\n", topicName);
1498 fprintf(Subsections, "+{\\footnote %s}\n", GetBrowseString());
1499 OutputSectionKeyword(Subsections);
1500 GenerateKeywordsForTopic(topicName);
1501 if (useUpButton && CurrentSectionName)
1502 {
1503 fprintf(Subsections, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
1504 FileNameFromPath(FileRoot), CurrentSectionName);
1505 }
1506 }
1507 if (!winHelp && indexSubsections && useWord)
1508 {
1509 // Insert index entry for this subsection
1510 TexOutput("{\\xe\\v {");
1511 OutputCurrentSection();
1512 TexOutput("}}");
1513 }
1514
1515 if (!InPopups())
1516 {
1517 char *styleCommand = "";
1518 if (!winHelp && useHeadingStyles && (macroId != ltSUBSECTIONSTAR))
1519 {
1520 if (DocumentStyle == LATEX_ARTICLE)
1521 styleCommand = "\\s2";
1522 else
1523 styleCommand = "\\s3";
1524 }
1525 char *keep = "";
1526 if (winHelp && !InPopups())
1527 keep = "\\keepn\\sa140\\sb140";
1528
1529 fprintf(winHelp ? Subsections : Chapters, "\\pard{%s%s",
1530 keep, styleCommand);
1531
1532 WriteHeadingStyle((winHelp ? Subsections : Chapters),
1533 (DocumentStyle == LATEX_ARTICLE ? 2 : 3));
1534 fprintf(winHelp ? Subsections : Chapters, " ");
1535
1536 if (!winHelp)
1537 {
1538 if ((macroId != ltSUBSECTIONSTAR) && (macroId != ltMEMBERSECTION) &&
1539 (macroId != ltFUNCTIONSECTION))
1540 {
1541 if (DocumentStyle == LATEX_REPORT)
1542 {
1543 if (useWord)
1544 // fprintf(Chapters, "{\\bkmkstart %s}%d.%d.%d{\\bkmkend %s}. ", topicName, chapterNo, sectionNo, subsectionNo,
1545 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1546 topicName);
1547 else
1548 fprintf(Chapters, "%d.%d.%d. ", chapterNo, sectionNo, subsectionNo);
1549 }
1550 else
1551 {
1552 if (useWord)
1553 // fprintf(Chapters, "{\\bkmkstart %s}%d.%d{\\bkmkend %s}. ", topicName, sectionNo, subsectionNo,
1554 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1555 topicName);
1556 else
1557 fprintf(Chapters, "%d.%d. ", sectionNo, subsectionNo);
1558 }
1559 }
1560 else if ( useWord )
1561 {
1562 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName, topicName);
1563 }
1564 }
1565 OutputCurrentSection(); // Repeat section header
1566 TexOutput("\\par\\pard}\\par\n");
1567 }
1568 issuedNewParagraph = 2;
1569 }
1570 }
1571 break;
1572 }
1573 case ltSUBSUBSECTION:
1574 case ltSUBSUBSECTIONSTAR:
1575 {
1576 if (!start)
1577 {
1578 if (winHelp && !Subsections)
1579 {
1580 OnError("You cannot have a subsubsection before a subsection!");
1581 }
1582 else
1583 {
1584 if (macroId != ltSUBSUBSECTIONSTAR)
1585 subsubsectionNo ++;
1586
1587 char *topicName = FindTopicName(GetNextChunk());
1588 SetCurrentTopic(topicName);
1589 NotifyParentHasChildren(3);
1590 if (winHelpContents && winHelp)
1591 {
1592 OutputCurrentSectionToString(wxBuffer);
1593 WriteWinHelpContentsFileLine(topicName, wxBuffer, 4);
1594 }
1595 AddTexRef(topicName, NULL, SectionNameString, chapterNo, sectionNo, subsectionNo, subsubsectionNo);
1596
1597 if (winHelp)
1598 {
1599 SetCurrentOutputs(Subsections, Subsubsections);
1600 fprintf(Subsections, "\n{\\uldb ");
1601 }
1602 else
1603 {
1604 if (macroId != ltSUBSUBSECTIONSTAR)
1605 {
1606 if (DocumentStyle == LATEX_ARTICLE)
1607 {
1608 SetCurrentOutput(Contents);
1609 fprintf(Contents, "\n\\tab\\tab %d.%d.%d\\tab ",
1610 sectionNo, subsectionNo, subsubsectionNo);
1611 }
1612 else
1613 SetCurrentOutput(NULL); // Don't write it into the contents, or anywhere else
1614 }
1615 else
1616 SetCurrentOutput(NULL); // Don't write it into the contents, or anywhere else
1617 }
1618
1619 if (startedSections)
1620 {
1621 if (winHelp)
1622 fprintf(Subsubsections, "\\page\n");
1623 else
1624 fprintf(Chapters, "\\par\n");
1625 }
1626
1627 startedSections = TRUE;
1628
1629 if (winHelp)
1630 fprintf(Subsubsections, "\n${\\footnote ");
1631
1632 // Output header to contents page
1633 OutputCurrentSection();
1634
1635 if (winHelp)
1636 fprintf(Subsections, "}{\\v %s}\\par\\pard\n", topicName);
1637 else if ((DocumentStyle == LATEX_ARTICLE) && (macroId != ltSUBSUBSECTIONSTAR))
1638 fprintf(Contents, "\\par\\pard\n");
1639
1640 SetCurrentOutput(winHelp ? Subsubsections : Chapters);
1641 if (winHelp)
1642 {
1643 fprintf(Subsubsections, "}\n#{\\footnote %s}\n", topicName);
1644 fprintf(Subsubsections, "+{\\footnote %s}\n", GetBrowseString());
1645 OutputSectionKeyword(Subsubsections);
1646 GenerateKeywordsForTopic(topicName);
1647 if (useUpButton && CurrentSubsectionName)
1648 {
1649 fprintf(Subsubsections, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
1650 FileNameFromPath(FileRoot), CurrentSubsectionName);
1651 }
1652 }
1653 if (!winHelp && indexSubsections && useWord)
1654 {
1655 // Insert index entry for this subsubsection
1656 TexOutput("{\\xe\\v {");
1657 OutputCurrentSection();
1658 TexOutput("}}");
1659 }
1660
1661 char *styleCommand = "";
1662 if (!winHelp && useHeadingStyles && (macroId != ltSUBSUBSECTIONSTAR))
1663 {
1664 if (DocumentStyle == LATEX_ARTICLE)
1665 styleCommand = "\\s3";
1666 else
1667 styleCommand = "\\s4";
1668 }
1669 char *keep = "";
1670 if (winHelp)
1671 keep = "\\keepn\\sa140\\sb140";
1672
1673 fprintf(winHelp ? Subsubsections : Chapters, "\\pard{%s%s",
1674 keep, styleCommand);
1675
1676 WriteHeadingStyle((winHelp ? Subsubsections : Chapters),
1677 (DocumentStyle == LATEX_ARTICLE ? 3 : 4));
1678 fprintf(winHelp ? Subsubsections : Chapters, " ");
1679
1680 if (!winHelp)
1681 {
1682 if ((macroId != ltSUBSUBSECTIONSTAR))
1683 {
1684 if (DocumentStyle == LATEX_ARTICLE)
1685 {
1686 if (useWord)
1687 // fprintf(Chapters, "{\\bkmkstart %s}%d.%d.%d{\\bkmkend %s}. ", topicName, sectionNo, subsectionNo, subsubsectionNo,
1688 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1689 topicName);
1690 else
1691 fprintf(Chapters, "%d.%d.%d. ", sectionNo, subsectionNo, subsubsectionNo);
1692 }
1693 else
1694 {
1695 if (useWord)
1696 // fprintf(Chapters, "{\\bkmkstart %s}%d.%d.%d.%d{\\bkmkend %s}. ", topicName, chapterNo, sectionNo, subsectionNo, subsubsectionNo,
1697 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName,
1698 topicName);
1699 else
1700 fprintf(Chapters, "%d.%d.%d.%d. ", chapterNo, sectionNo, subsectionNo, subsubsectionNo);
1701 }
1702 }
1703 else if ( useWord )
1704 {
1705 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", topicName, topicName);
1706 }
1707 }
1708 OutputCurrentSection(); // Repeat section header
1709 TexOutput("\\par\\pard}\\par\n");
1710 issuedNewParagraph = 2;
1711 // if (winHelp) TexOutput("\\pard");
1712 }
1713 }
1714 break;
1715 }
1716 case ltCAPTION:
1717 case ltCAPTIONSTAR:
1718 {
1719 if (!start)
1720 {
1721 char *topicName = FindTopicName(GetNextChunk());
1722 SetCurrentTopic(topicName);
1723
1724 TexOutput("\\pard\\par");
1725 char figBuf[200];
1726
1727 if (inFigure)
1728 {
1729 figureNo ++;
1730
1731 if (winHelp || !useWord)
1732 {
1733 if (DocumentStyle != LATEX_ARTICLE)
1734 sprintf(figBuf, "%s %d.%d: ", FigureNameString, chapterNo, figureNo);
1735 else
1736 sprintf(figBuf, "%s %d: ", FigureNameString, figureNo);
1737 }
1738 else
1739 {
1740 sprintf(figBuf, "%s {\\field\\flddirty{\\*\\fldinst SEQ Figure \\\\* ARABIC }{\\fldrslt {\\bkmkstart %s}??{\\bkmkend %s}}}: ",
1741 FigureNameString, topicName, topicName);
1742 }
1743 }
1744 else
1745 {
1746 tableNo ++;
1747
1748 if (winHelp || !useWord)
1749 {
1750 if (DocumentStyle != LATEX_ARTICLE)
1751 sprintf(figBuf, "%s %d.%d: ", TableNameString, chapterNo, tableNo);
1752 else
1753 sprintf(figBuf, "%s %d: ", TableNameString, tableNo);
1754 }
1755 else
1756 {
1757 sprintf(figBuf, "%s {\\field\\flddirty{\\*\\fldinst SEQ Table \\\\* ARABIC }{\\fldrslt {\\bkmkstart %s}??{\\bkmkend %s}}}: ",
1758 TableNameString, topicName, topicName);
1759 }
1760 }
1761
1762 int n = (inTable ? tableNo : figureNo);
1763 AddTexRef(topicName, NULL, NULL,
1764 ((DocumentStyle != LATEX_ARTICLE) ? chapterNo : n),
1765 ((DocumentStyle != LATEX_ARTICLE) ? n : 0));
1766
1767 if (winHelp)
1768 TexOutput("\\qc{\\b ");
1769 else
1770 TexOutput("\\ql{\\b ");
1771 TexOutput(figBuf);
1772
1773 OutputCurrentSection();
1774
1775 TexOutput("}\\par\\pard\n");
1776 WriteEnvironmentStyles();
1777 }
1778 break;
1779 }
1780 case ltFUNC:
1781 case ltPFUNC:
1782 {
1783 // SetCurrentOutput(winHelp ? Subsections : Chapters);
1784 if (start)
1785 {
1786 TexOutput("{");
1787 }
1788 else
1789 {
1790 TexOutput("}\n");
1791 if (winHelp)
1792 {
1793 TexOutput("K{\\footnote {K} ");
1794 suppressNameDecoration = TRUE;
1795 TraverseChildrenFromChunk(currentMember);
1796 suppressNameDecoration = FALSE;
1797 TexOutput("}\n");
1798 }
1799 if (!winHelp && useWord)
1800 {
1801 // Insert index entry for this function
1802 TexOutput("{\\xe\\v {");
1803 suppressNameDecoration = TRUE; // Necessary so don't print "(\\bf" etc.
1804 TraverseChildrenFromChunk(currentMember);
1805 suppressNameDecoration = FALSE;
1806 TexOutput("}}");
1807 }
1808 }
1809 break;
1810 }
1811 case ltCLIPSFUNC:
1812 {
1813 // SetCurrentOutput(winHelp ? Subsections : Chapters);
1814 if (start)
1815 {
1816 TexOutput("{");
1817 }
1818 else
1819 {
1820 TexOutput("}\n");
1821 if (winHelp)
1822 {
1823 TexOutput("K{\\footnote {K} ");
1824 suppressNameDecoration = TRUE; // Necessary so don't print "(\\bf" etc.
1825 TraverseChildrenFromChunk(currentMember);
1826 suppressNameDecoration = FALSE;
1827 TexOutput("}\n");
1828 }
1829 if (!winHelp && useWord)
1830 {
1831 // Insert index entry for this function
1832 TexOutput("{\\xe\\v {");
1833 suppressNameDecoration = TRUE; // Necessary so don't print "(\\bf" etc.
1834 TraverseChildrenFromChunk(currentMember);
1835 suppressNameDecoration = FALSE;
1836 TexOutput("}}");
1837 }
1838 }
1839 break;
1840 }
1841 case ltMEMBER:
1842 {
1843 // SetCurrentOutput(winHelp ? Subsections : Chapters);
1844 if (start)
1845 {
1846 TexOutput("{\\b ");
1847 }
1848 else
1849 {
1850 TexOutput("}\n");
1851 if (winHelp)
1852 {
1853 TexOutput("K{\\footnote {K} ");
1854 TraverseChildrenFromChunk(currentMember);
1855 TexOutput("}\n");
1856 }
1857 if (!winHelp && useWord)
1858 {
1859 // Insert index entry for this function
1860 TexOutput("{\\xe\\v {");
1861 suppressNameDecoration = TRUE; // Necessary so don't print "(\\bf" etc.
1862 TraverseChildrenFromChunk(currentMember);
1863 suppressNameDecoration = FALSE;
1864 TexOutput("}}");
1865 }
1866 }
1867 break;
1868 }
1869 case ltDOCUMENT:
1870 {
1871 if (start)
1872 SetCurrentOutput(Chapters);
1873 break;
1874 }
1875 case ltTABLEOFCONTENTS:
1876 {
1877 if (start)
1878 {
1879 if (!winHelp && useWord)
1880 {
1881 // Insert Word for Windows table of contents
1882 TexOutput("\\par\\pard\\pgnrestart\\sect\\titlepg");
1883
1884 // In linear RTF, same as chapter headings.
1885 sprintf(buf, "{\\b\\fs%d %s}\\par\\par\\pard\n\n", chapterFont*2, ContentsNameString);
1886
1887 TexOutput(buf);
1888 sprintf(buf, "{\\field{\\*\\fldinst TOC \\\\o \"1-%d\" }{\\fldrslt PRESS F9 TO REFORMAT CONTENTS}}\n", contentsDepth);
1889 TexOutput(buf);
1890 // TexOutput("\\sect\\sectd");
1891 }
1892 else
1893 {
1894 FILE *fd = fopen(ContentsName, "r");
1895 if (fd)
1896 {
1897 int ch = getc(fd);
1898 while (ch != EOF)
1899 {
1900 putc(ch, Chapters);
1901 ch = getc(fd);
1902 }
1903 fclose(fd);
1904 }
1905 else
1906 {
1907 TexOutput("{\\i RUN TEX2RTF AGAIN FOR CONTENTS PAGE}\\par\n");
1908 OnInform("Run Tex2RTF again to include contents page.");
1909 }
1910 }
1911 }
1912 break;
1913 }
1914 case ltVOID:
1915 {
1916 // if (start)
1917 // TexOutput("{\\b void}");
1918 break;
1919 }
1920 case ltHARDY:
1921 {
1922 if (start)
1923 TexOutput("{\\scaps HARDY}");
1924 break;
1925 }
1926 case ltWXCLIPS:
1927 {
1928 if (start)
1929 TexOutput("wxCLIPS");
1930 break;
1931 }
1932 case ltSPECIALAMPERSAND:
1933 {
1934 if (start)
1935 {
1936 if (inTabular)
1937 TexOutput("\\cell ");
1938 else
1939 TexOutput("&");
1940 }
1941 break;
1942 }
1943 case ltSPECIALTILDE:
1944 {
1945 if (start)
1946 {
1947 if (inVerbatim)
1948 TexOutput("~");
1949 else
1950 TexOutput(" ");
1951 }
1952 break;
1953 }
1954 case ltBACKSLASHCHAR:
1955 {
1956 if (start)
1957 {
1958 if (inTabular)
1959 {
1960 // TexOutput("\\cell\\row\\trowd\\trgaph108\\trleft-108\n");
1961 TexOutput("\\cell\\row\\trowd\\trgaph108\n");
1962 int currentWidth = 0;
1963 for (int i = 0; i < noColumns; i++)
1964 {
1965 currentWidth += TableData[i].width;
1966 if (TableData[i].rightBorder)
1967 TexOutput("\\clbrdrr\\brdrs\\brdrw15");
1968
1969 if (TableData[i].leftBorder)
1970 TexOutput("\\clbrdrl\\brdrs\\brdrw15");
1971
1972 sprintf(buf, "\\cellx%d", currentWidth);
1973 TexOutput(buf);
1974 }
1975 TexOutput("\\pard\\intbl\n");
1976 }
1977 else
1978 TexOutput("\\line\n");
1979 }
1980 break;
1981 }
1982 case ltRANGLEBRA:
1983 {
1984 if (start)
1985 TexOutput("\tab ");
1986 break;
1987 }
1988 case ltRTFSP: // Explicit space, RTF only
1989 {
1990 if (start)
1991 TexOutput(" ");
1992 break;
1993 }
1994 case ltITEMIZE:
1995 case ltENUMERATE:
1996 case ltDESCRIPTION:
1997 {
1998 if (start)
1999 {
2000 if (indentLevel > 0)
2001 {
2002 TexOutput("\\par\\par\n");
2003 issuedNewParagraph = 2;
2004 }
2005 else
2006 {
2007 // Top-level list: issue a new paragraph if we haven't
2008 // just done so
2009 if (!issuedNewParagraph)
2010 {
2011 TexOutput("\\par\\pard");
2012 WriteEnvironmentStyles();
2013 issuedNewParagraph = 1;
2014 }
2015 else issuedNewParagraph = 0;
2016 }
2017 indentLevel ++;
2018 TexOutput("\\fi0\n");
2019 int listType;
2020 if (macroId == ltENUMERATE)
2021 listType = LATEX_ENUMERATE;
2022 else if (macroId == ltITEMIZE)
2023 listType = LATEX_ITEMIZE;
2024 else
2025 listType = LATEX_DESCRIPTION;
2026
2027 int oldIndent = 0;
2028 wxNode *node = itemizeStack.First();
2029 if (node)
2030 oldIndent = ((ItemizeStruc *)node->Data())->indentation;
2031
2032 int indentSize1 = oldIndent + 20*labelIndentTab;
2033 int indentSize2 = oldIndent + 20*itemIndentTab;
2034
2035 ItemizeStruc *struc = new ItemizeStruc(listType, indentSize2, indentSize1);
2036 itemizeStack.Insert(struc);
2037
2038 sprintf(buf, "\\tx%d\\tx%d\\li%d", indentSize1, indentSize2, indentSize2);
2039 PushEnvironmentStyle(buf);
2040 }
2041 else
2042 {
2043 currentItemSep = 8; // Reset to the default
2044 indentLevel --;
2045 PopEnvironmentStyle();
2046
2047 if (itemizeStack.First())
2048 {
2049 ItemizeStruc *struc = (ItemizeStruc *)itemizeStack.First()->Data();
2050 delete struc;
2051 delete itemizeStack.First();
2052 }
2053 /* Change 18/7/97 - don't know why we wish to do this
2054 if (itemizeStack.Number() == 0)
2055 {
2056 OnMacro(ltPAR, 0, TRUE);
2057 OnMacro(ltPAR, 0, FALSE);
2058 issuedNewParagraph = 2;
2059 }
2060 */
2061 }
2062 break;
2063 }
2064 case ltTWOCOLLIST:
2065 {
2066 if (start)
2067 {
2068 indentLevel ++;
2069 int oldIndent = 0;
2070 wxNode *node = itemizeStack.First();
2071 if (node)
2072 oldIndent = ((ItemizeStruc *)node->Data())->indentation;
2073
2074 int indentSize = oldIndent + TwoColWidthA;
2075
2076 ItemizeStruc *struc = new ItemizeStruc(LATEX_TWOCOL, indentSize);
2077 itemizeStack.Insert(struc);
2078
2079 // sprintf(buf, "\\tx%d\\li%d\\ri%d", indentSize, indentSize, TwoColWidthA+TwoColWidthB+oldIndent);
2080 sprintf(buf, "\\tx%d\\li%d", indentSize, indentSize);
2081 PushEnvironmentStyle(buf);
2082 }
2083 else
2084 {
2085 indentLevel --;
2086 PopEnvironmentStyle();
2087 if (itemizeStack.First())
2088 {
2089 ItemizeStruc *struc = (ItemizeStruc *)itemizeStack.First()->Data();
2090 delete struc;
2091 delete itemizeStack.First();
2092 }
2093 /*
2094 // JACS June 1997
2095 TexOutput("\\pard\n");
2096 WriteEnvironmentStyles();
2097 */
2098 /* why do we need this? */
2099 if (itemizeStack.Number() == 0)
2100 {
2101 issuedNewParagraph = 0;
2102 OnMacro(ltPAR, 0, TRUE);
2103 OnMacro(ltPAR, 0, FALSE);
2104 }
2105 }
2106 break;
2107 }
2108 case ltITEM:
2109 {
2110 wxNode *node = itemizeStack.First();
2111 if (node)
2112 {
2113 ItemizeStruc *struc = (ItemizeStruc *)node->Data();
2114 if (!start)
2115 {
2116 struc->currentItem += 1;
2117 char indentBuf[60];
2118
2119 int indentSize1 = struc->labelIndentation;
2120 int indentSize2 = struc->indentation;
2121
2122 TexOutput("\n");
2123 if (struc->currentItem > 1)
2124 {
2125 if (currentItemSep > 0)
2126 TexOutput("\\par");
2127
2128 TexOutput("\\par");
2129 // WriteEnvironmentStyles();
2130 }
2131
2132 sprintf(buf, "\\tx%d\\tx%d\\li%d\\fi-%d\n", indentSize1, indentSize2,
2133 indentSize2, 20*itemIndentTab);
2134 TexOutput(buf);
2135
2136 switch (struc->listType)
2137 {
2138 case LATEX_ENUMERATE:
2139 {
2140 if (descriptionItemArg)
2141 {
2142 TexOutput("\\tab{ ");
2143 TraverseChildrenFromChunk(descriptionItemArg);
2144 TexOutput("}\\tab");
2145 descriptionItemArg = NULL;
2146 }
2147 else
2148 {
2149 sprintf(indentBuf, "\\tab{\\b %d.}\\tab", struc->currentItem);
2150 TexOutput(indentBuf);
2151 }
2152 break;
2153 }
2154 case LATEX_ITEMIZE:
2155 {
2156 if (descriptionItemArg)
2157 {
2158 TexOutput("\\tab{ ");
2159 TraverseChildrenFromChunk(descriptionItemArg);
2160 TexOutput("}\\tab");
2161 descriptionItemArg = NULL;
2162 }
2163 else
2164 {
2165 if (bulletFile && winHelp)
2166 {
2167 if (winHelpVersion > 3) // Transparent bitmap
2168 sprintf(indentBuf, "\\tab\\{bmct %s\\}\\tab", bulletFile);
2169 else
2170 sprintf(indentBuf, "\\tab\\{bmc %s\\}\\tab", bulletFile);
2171 }
2172 else if (winHelp)
2173 sprintf(indentBuf, "\\tab{\\b o}\\tab");
2174 else
2175 sprintf(indentBuf, "\\tab{\\f1\\'b7}\\tab");
2176 TexOutput(indentBuf);
2177 }
2178 break;
2179 }
2180 default:
2181 case LATEX_DESCRIPTION:
2182 {
2183 if (descriptionItemArg)
2184 {
2185 TexOutput("\\tab{\\b ");
2186 TraverseChildrenFromChunk(descriptionItemArg);
2187 TexOutput("} ");
2188 descriptionItemArg = NULL;
2189 }
2190 break;
2191 }
2192 }
2193 }
2194 }
2195 break;
2196 }
2197 case ltTWOCOLITEM:
2198 case ltTWOCOLITEMRULED:
2199 {
2200 wxNode *node = itemizeStack.First();
2201 if (node)
2202 {
2203 ItemizeStruc *struc = (ItemizeStruc *)node->Data();
2204 if (start)
2205 {
2206 struc->currentItem += 1;
2207
2208 int indentSize = struc->indentation;
2209 int oldIndent = 0;
2210 wxNode *node2 = NULL;
2211 if (itemizeStack.Number() > 1) // TODO: do I actually mean Nth(0) here??
2212 node2 = itemizeStack.Nth(1);
2213 if (node2)
2214 oldIndent = ((ItemizeStruc *)node2->Data())->indentation;
2215
2216 TexOutput("\n");
2217 if (struc->currentItem > 1)
2218 {
2219 if (currentItemSep > 0)
2220 TexOutput("\\par");
2221
2222 // WriteEnvironmentStyles();
2223 }
2224
2225 // sprintf(buf, "\\tx%d\\li%d\\fi-%d\\ri%d\n", TwoColWidthA,
2226 // TwoColWidthA, TwoColWidthA, TwoColWidthA+TwoColWidthB+oldIndent);
2227 /*
2228 sprintf(buf, "\\tx%d\\li%d\\fi-%d\n", TwoColWidthA,
2229 TwoColWidthA, TwoColWidthA);
2230 */
2231 sprintf(buf, "\\tx%d\\li%d\\fi-%d\n", TwoColWidthA + oldIndent,
2232 TwoColWidthA + oldIndent, TwoColWidthA);
2233 TexOutput(buf);
2234 }
2235 }
2236 break;
2237 }
2238 case ltVERBATIM:
2239 case ltVERB:
2240 {
2241 if (start)
2242 {
2243 if (macroId == ltVERBATIM)
2244 {
2245 if (!issuedNewParagraph)
2246 {
2247 TexOutput("\\par\\pard");
2248 WriteEnvironmentStyles();
2249 issuedNewParagraph = 1;
2250 }
2251 else issuedNewParagraph = 0;
2252 }
2253 sprintf(buf, "{\\f3\\fs20 ");
2254 TexOutput(buf);
2255 }
2256 else
2257 {
2258 TexOutput("}");
2259 if (macroId == ltVERBATIM)
2260 {
2261 TexOutput("\\pard\n");
2262 // issuedNewParagraph = 1;
2263 WriteEnvironmentStyles();
2264 }
2265 }
2266 break;
2267 }
2268 case ltCENTERLINE:
2269 case ltCENTER:
2270 {
2271 if (start)
2272 {
2273 TexOutput("\\fi0\\qc ");
2274 forbidParindent ++;
2275 PushEnvironmentStyle("\\qc");
2276 }
2277 else
2278 {
2279 TexOutput("\\par\\pard\n");
2280 issuedNewParagraph = 1;
2281 forbidParindent --;
2282 PopEnvironmentStyle();
2283 WriteEnvironmentStyles();
2284 }
2285 break;
2286 }
2287 case ltFLUSHLEFT:
2288 {
2289 if (start)
2290 {
2291 TexOutput("\\fi0\\ql ");
2292 forbidParindent ++;
2293 PushEnvironmentStyle("\\ql");
2294 }
2295 else
2296 {
2297 TexOutput("\\par\\pard\n");
2298 issuedNewParagraph = 1;
2299 forbidParindent --;
2300 PopEnvironmentStyle();
2301 WriteEnvironmentStyles();
2302 }
2303 break;
2304 }
2305 case ltFLUSHRIGHT:
2306 {
2307 if (start)
2308 {
2309 TexOutput("\\fi0\\qr ");
2310 forbidParindent ++;
2311 PushEnvironmentStyle("\\qr");
2312 }
2313 else
2314 {
2315 TexOutput("\\par\\pard\n");
2316 issuedNewParagraph = 1;
2317 forbidParindent --;
2318 PopEnvironmentStyle();
2319 WriteEnvironmentStyles();
2320 }
2321 break;
2322 }
2323 case ltSMALL:
2324 case ltFOOTNOTESIZE:
2325 {
2326 if (start)
2327 {
2328 sprintf(buf, "{\\fs%d\n", smallFont*2);
2329 TexOutput(buf);
2330 }
2331 else TexOutput("}\n");
2332 break;
2333 }
2334 case ltTINY:
2335 case ltSCRIPTSIZE:
2336 {
2337 if (start)
2338 {
2339 sprintf(buf, "{\\fs%d\n", tinyFont*2);
2340 TexOutput(buf);
2341 }
2342 else TexOutput("}\n");
2343 break;
2344 }
2345 case ltNORMALSIZE:
2346 {
2347 if (start)
2348 {
2349 sprintf(buf, "{\\fs%d\n", normalFont*2);
2350 TexOutput(buf);
2351 }
2352 else TexOutput("}\n");
2353 break;
2354 }
2355 case ltlarge:
2356 {
2357 if (start)
2358 {
2359 sprintf(buf, "{\\fs%d\n", largeFont1*2);
2360 TexOutput(buf);
2361 }
2362 else TexOutput("}\n");
2363 break;
2364 }
2365 case ltLarge:
2366 {
2367 if (start)
2368 {
2369 sprintf(buf, "{\\fs%d\n", LargeFont2*2);
2370 TexOutput(buf);
2371 }
2372 else TexOutput("}\n");
2373 break;
2374 }
2375 case ltLARGE:
2376 {
2377 if (start)
2378 {
2379 sprintf(buf, "{\\fs%d\n", LARGEFont3*2);
2380 TexOutput(buf);
2381 }
2382 else TexOutput("}\n");
2383 break;
2384 }
2385 case lthuge:
2386 {
2387 if (start)
2388 {
2389 sprintf(buf, "{\\fs%d\n", hugeFont1*2);
2390 TexOutput(buf);
2391 }
2392 else TexOutput("}\n");
2393 break;
2394 }
2395 case ltHuge:
2396 {
2397 if (start)
2398 {
2399 sprintf(buf, "{\\fs%d\n", HugeFont2*2);
2400 TexOutput(buf);
2401 }
2402 else TexOutput("}\n");
2403 break;
2404 }
2405 case ltHUGE:
2406 {
2407 if (start)
2408 {
2409 sprintf(buf, "{\\fs%d\n", HUGEFont3*2);
2410 TexOutput(buf);
2411 }
2412 else TexOutput("}\n");
2413 break;
2414 }
2415 case ltTEXTBF:
2416 case ltBFSERIES:
2417 case ltBF:
2418 {
2419 if (start)
2420 {
2421 TexOutput("{\\b ");
2422 }
2423 else TexOutput("}");
2424 break;
2425 }
2426 case ltUNDERLINE:
2427 {
2428 if (start)
2429 {
2430 TexOutput("{\\ul ");
2431 }
2432 else TexOutput("}");
2433 break;
2434 }
2435 case ltTEXTIT:
2436 case ltITSHAPE:
2437 case ltIT:
2438 case ltEMPH:
2439 case ltEM:
2440 {
2441 if (start)
2442 {
2443 TexOutput("{\\i ");
2444 }
2445 else TexOutput("}");
2446 break;
2447 }
2448 // Roman font: do nothing. Should really switch between
2449 // fonts.
2450 case ltTEXTRM:
2451 case ltRMFAMILY:
2452 case ltRM:
2453 {
2454 /*
2455 if (start)
2456 {
2457 TexOutput("{\\plain ");
2458 }
2459 else TexOutput("}");
2460 */
2461 break;
2462 }
2463 // Medium-weight font. Unbolden...
2464 case ltMDSERIES:
2465 {
2466 if (start)
2467 {
2468 TexOutput("{\\b0 ");
2469 }
2470 else TexOutput("}");
2471 break;
2472 }
2473 // Upright (un-italic or slant)
2474 case ltUPSHAPE:
2475 {
2476 if (start)
2477 {
2478 TexOutput("{\\i0 ");
2479 }
2480 else TexOutput("}");
2481 break;
2482 }
2483 case ltTEXTSC:
2484 case ltSCSHAPE:
2485 case ltSC:
2486 {
2487 if (start)
2488 {
2489 TexOutput("{\\scaps ");
2490 }
2491 else TexOutput("}");
2492 break;
2493 }
2494 case ltTEXTTT:
2495 case ltTTFAMILY:
2496 case ltTT:
2497 {
2498 if (start)
2499 {
2500 TexOutput("{\\f3 ");
2501 }
2502 else TexOutput("}");
2503 break;
2504 }
2505 case ltLBRACE:
2506 {
2507 if (start)
2508 TexOutput("\\{");
2509 break;
2510 }
2511 case ltRBRACE:
2512 {
2513 if (start)
2514 TexOutput("\\}");
2515 break;
2516 }
2517 case ltBACKSLASH:
2518 {
2519 if (start)
2520 TexOutput("\\\\");
2521 break;
2522 }
2523 case ltPAR:
2524 {
2525 if (start)
2526 {
2527 if ( issuedNewParagraph == 0 )
2528 {
2529 TexOutput("\\par\\pard");
2530 issuedNewParagraph ++;
2531
2532 // Extra par if parskip is more than zero (usually looks best.)
2533 if (!inTabular && (ParSkip > 0))
2534 {
2535 TexOutput("\\par");
2536 issuedNewParagraph ++;
2537 }
2538 WriteEnvironmentStyles();
2539 }
2540 // 1 is a whole paragraph if ParSkip == 0,
2541 // half a paragraph if ParSkip > 0
2542 else if ( issuedNewParagraph == 1 )
2543 {
2544 // Don't need a par at all if we've already had one,
2545 // and ParSkip == 0.
2546
2547 // Extra par if parskip is more than zero (usually looks best.)
2548 if (!inTabular && (ParSkip > 0))
2549 {
2550 TexOutput("\\par");
2551 issuedNewParagraph ++;
2552 }
2553 WriteEnvironmentStyles();
2554 }
2555 /*
2556 if (!issuedNewParagraph || (issuedNewParagraph > 1))
2557 {
2558 TexOutput("\\par\\pard");
2559
2560 // Extra par if parskip is more than zero (usually looks best.)
2561 if (!inTabular && (ParSkip > 0))
2562 TexOutput("\\par");
2563 WriteEnvironmentStyles();
2564 }
2565 */
2566
2567 TexOutput("\n");
2568 }
2569 break;
2570 }
2571 case ltNEWPAGE:
2572 {
2573 // In Windows Help, no newpages until we've started some chapters or sections
2574 if (!(winHelp && !startedSections))
2575 if (start)
2576 TexOutput("\\page\n");
2577 break;
2578 }
2579 case ltMAKETITLE:
2580 {
2581 if (start && DocumentTitle)
2582 {
2583 TexOutput("\\par\\pard");
2584 if (!winHelp)
2585 TexOutput("\\par");
2586 sprintf(buf, "\\qc{\\fs%d\\b ", titleFont*2);
2587 TexOutput(buf);
2588 TraverseChildrenFromChunk(DocumentTitle);
2589 TexOutput("}\\par\\pard\n");
2590
2591 if (DocumentAuthor)
2592 {
2593 if (!winHelp)
2594 TexOutput("\\par");
2595 sprintf(buf, "\\par\\qc{\\fs%d ", authorFont*2);
2596 TexOutput(buf);
2597 TraverseChildrenFromChunk(DocumentAuthor);
2598 TexOutput("}");
2599 TexOutput("\\par\\pard\n");
2600 }
2601 if (DocumentDate)
2602 {
2603 TexOutput("\\par");
2604 sprintf(buf, "\\qc{\\fs%d ", authorFont*2);
2605 TexOutput(buf);
2606 TraverseChildrenFromChunk(DocumentDate);
2607 TexOutput("}\\par\\pard\n");
2608 }
2609 // If linear RTF, we want this titlepage to be in a separate
2610 // section with its own (blank) header and footer
2611 if (!winHelp && (DocumentStyle != LATEX_ARTICLE))
2612 {
2613 TexOutput("{\\header }{\\footer }\n");
2614 // Not sure about this: we get too many sections.
2615 // TexOutput("\\sect");
2616 }
2617 }
2618 break;
2619 }
2620 case ltADDCONTENTSLINE:
2621 {
2622 if (!start)
2623 {
2624 if (contentsLineSection && contentsLineValue)
2625 {
2626 if (strcmp(contentsLineSection, "chapter") == 0)
2627 {
2628 fprintf(Contents, "\\par\n{\\b %s}\\par\n", contentsLineValue);
2629 }
2630 else if (strcmp(contentsLineSection, "section") == 0)
2631 {
2632 if (DocumentStyle != LATEX_ARTICLE)
2633 fprintf(Contents, "\n\\tab%s\\par\n", contentsLineValue);
2634 else
2635 fprintf(Contents, "\\par\n{\\b %s}\\par\n", contentsLineValue);
2636 }
2637 }
2638 }
2639 break;
2640 }
2641 case ltHRULE:
2642 {
2643 if (start)
2644 {
2645 TexOutput("\\brdrb\\brdrs\\par\\pard\n");
2646 issuedNewParagraph = 1;
2647 WriteEnvironmentStyles();
2648 }
2649 break;
2650 }
2651 case ltRULE:
2652 {
2653 if (start)
2654 {
2655 TexOutput("\\brdrb\\brdrs\\par\\pard\n");
2656 issuedNewParagraph = 1;
2657 WriteEnvironmentStyles();
2658 }
2659 break;
2660 }
2661 case ltHLINE:
2662 {
2663 if (start)
2664 ruleTop ++;
2665 break;
2666 }
2667 case ltNUMBEREDBIBITEM:
2668 {
2669 if (start)
2670 TexOutput("\\li260\\fi-260 "); // Indent from 2nd line
2671 else
2672 TexOutput("\\par\\pard\\par\n\n");
2673 break;
2674 }
2675 case ltTHEPAGE:
2676 {
2677 if (start)
2678 {
2679 TexOutput("{\\field{\\*\\fldinst PAGE \\\\* MERGEFORMAT }{\\fldrslt 1}}");
2680 }
2681 break;
2682 }
2683 case ltTHECHAPTER:
2684 {
2685 if (start)
2686 {
2687 // TexOutput("{\\field{\\*\\fldinst SECTION \\\\* MERGEFORMAT }{\\fldrslt 1}}");
2688 sprintf(buf, "%d", chapterNo);
2689 TexOutput(buf);
2690 }
2691 break;
2692 }
2693 case ltTHESECTION:
2694 {
2695 if (start)
2696 {
2697 // TexOutput("{\\field{\\*\\fldinst SECTION \\\\* MERGEFORMAT }{\\fldrslt 1}}");
2698 sprintf(buf, "%d", sectionNo);
2699 TexOutput(buf);
2700 }
2701 break;
2702 }
2703 case ltTWOCOLUMN:
2704 {
2705 if (!start && !winHelp)
2706 {
2707 TexOutput("\\cols2\n");
2708 }
2709 break;
2710 }
2711 case ltONECOLUMN:
2712 {
2713 if (!start && !winHelp)
2714 {
2715 TexOutput("\\cols1\n");
2716 }
2717 break;
2718 }
2719 case ltPRINTINDEX:
2720 {
2721 if (start && useWord && !winHelp)
2722 {
2723 FakeCurrentSection("Index");
2724 OnMacro(ltPAR, 0, TRUE);
2725 OnMacro(ltPAR, 0, FALSE);
2726 TexOutput("\\par{\\field{\\*\\fldinst INDEX \\\\h \"\\emdash A\\emdash \"\\\\c \"2\"}{\\fldrslt PRESS F9 TO REFORMAT INDEX}}\n");
2727 }
2728 break;
2729 }
2730 case ltLISTOFFIGURES:
2731 {
2732 if (start && useWord && !winHelp)
2733 {
2734 FakeCurrentSection(FiguresNameString, FALSE);
2735 OnMacro(ltPAR, 0, TRUE);
2736 OnMacro(ltPAR, 0, FALSE);
2737 OnMacro(ltPAR, 0, TRUE);
2738 OnMacro(ltPAR, 0, FALSE);
2739 char buf[200];
2740 sprintf(buf, "{\\field\\fldedit{\\*\\fldinst TOC \\\\c \"%s\" }{\\fldrslt PRESS F9 TO REFORMAT LIST OF FIGURES}}\n",
2741 FigureNameString);
2742 TexOutput(buf);
2743 }
2744 break;
2745 }
2746 case ltLISTOFTABLES:
2747 {
2748 if (start && useWord && !winHelp)
2749 {
2750 FakeCurrentSection(TablesNameString, FALSE);
2751 OnMacro(ltPAR, 0, TRUE);
2752 OnMacro(ltPAR, 0, FALSE);
2753 OnMacro(ltPAR, 0, TRUE);
2754 OnMacro(ltPAR, 0, FALSE);
2755 char buf[200];
2756 sprintf(buf, "{\\field\\fldedit{\\*\\fldinst TOC \\\\c \"%s\" }{\\fldrslt PRESS F9 TO REFORMAT LIST OF TABLES}}\n",
2757 TablesNameString);
2758 TexOutput(buf);
2759 }
2760 break;
2761 }
2762 // Symbols
2763 case ltALPHA:
2764 if (start) TexOutput("{\\f1\\'61}");
2765 break;
2766 case ltBETA:
2767 if (start) TexOutput("{\\f1\\'62}");
2768 break;
2769 case ltGAMMA:
2770 if (start) TexOutput("{\\f1\\'63}");
2771 break;
2772 case ltDELTA:
2773 if (start) TexOutput("{\\f1\\'64}");
2774 break;
2775 case ltEPSILON:
2776 case ltVAREPSILON:
2777 if (start) TexOutput("{\\f1\\'65}");
2778 break;
2779 case ltZETA:
2780 if (start) TexOutput("{\\f1\\'7A}");
2781 break;
2782 case ltETA:
2783 if (start) TexOutput("{\\f1\\'68}");
2784 break;
2785 case ltTHETA:
2786 case ltVARTHETA:
2787 if (start) TexOutput("{\\f1\\'71}");
2788 break;
2789 case ltIOTA:
2790 if (start) TexOutput("{\\f1\\'69}");
2791 break;
2792 case ltKAPPA:
2793 if (start) TexOutput("{\\f1\\'6B}");
2794 break;
2795 case ltLAMBDA:
2796 if (start) TexOutput("{\\f1\\'6C}");
2797 break;
2798 case ltMU:
2799 if (start) TexOutput("{\\f1\\'6D}");
2800 break;
2801 case ltNU:
2802 if (start) TexOutput("{\\f1\\'6E}");
2803 break;
2804 case ltXI:
2805 if (start) TexOutput("{\\f1\\'78}");
2806 break;
2807 case ltPI:
2808 if (start) TexOutput("{\\f1\\'70}");
2809 break;
2810 case ltVARPI:
2811 if (start) TexOutput("{\\f1\\'76}");
2812 break;
2813 case ltRHO:
2814 case ltVARRHO:
2815 if (start) TexOutput("{\\f1\\'72}");
2816 break;
2817 case ltSIGMA:
2818 if (start) TexOutput("{\\f1\\'73}");
2819 break;
2820 case ltVARSIGMA:
2821 if (start) TexOutput("{\\f1\\'56}");
2822 break;
2823 case ltTAU:
2824 if (start) TexOutput("{\\f1\\'74}");
2825 break;
2826 case ltUPSILON:
2827 if (start) TexOutput("{\\f1\\'75}");
2828 break;
2829 case ltPHI:
2830 case ltVARPHI:
2831 if (start) TexOutput("{\\f1\\'66}");
2832 break;
2833 case ltCHI:
2834 if (start) TexOutput("{\\f1\\'63}");
2835 break;
2836 case ltPSI:
2837 if (start) TexOutput("{\\f1\\'79}");
2838 break;
2839 case ltOMEGA:
2840 if (start) TexOutput("{\\f1\\'77}");
2841 break;
2842 case ltCAP_GAMMA:
2843 if (start) TexOutput("{\\f1\\'47}");
2844 break;
2845 case ltCAP_DELTA:
2846 if (start) TexOutput("{\\f1\\'44}");
2847 break;
2848 case ltCAP_THETA:
2849 if (start) TexOutput("{\\f1\\'51}");
2850 break;
2851 case ltCAP_LAMBDA:
2852 if (start) TexOutput("{\\f1\\'4C}");
2853 break;
2854 case ltCAP_XI:
2855 if (start) TexOutput("{\\f1\\'58}");
2856 break;
2857 case ltCAP_PI:
2858 if (start) TexOutput("{\\f1\\'50}");
2859 break;
2860 case ltCAP_SIGMA:
2861 if (start) TexOutput("{\\f1\\'53}");
2862 break;
2863 case ltCAP_UPSILON:
2864 if (start) TexOutput("{\\f1\\'54}");
2865 break;
2866 case ltCAP_PHI:
2867 if (start) TexOutput("{\\f1\\'46}");
2868 break;
2869 case ltCAP_PSI:
2870 if (start) TexOutput("{\\f1\\'59}");
2871 break;
2872 case ltCAP_OMEGA:
2873 if (start) TexOutput("{\\f1\\'57}");
2874 break;
2875 // Binary operation symbols
2876 case ltLE:
2877 case ltLEQ:
2878 if (start) TexOutput("{\\f1\\'A3}");
2879 break;
2880 case ltLL:
2881 if (start) TexOutput("<<");
2882 break;
2883 case ltSUBSET:
2884 if (start) TexOutput("{\\f1\\'CC}");
2885 break;
2886 case ltSUBSETEQ:
2887 if (start) TexOutput("{\\f1\\'CD}");
2888 break;
2889 case ltIN:
2890 if (start) TexOutput("{\\f1\\'CE}");
2891 break;
2892 case ltGE:
2893 case ltGEQ:
2894 if (start) TexOutput("{\\f1\\'B3}");
2895 break;
2896 case ltGG:
2897 if (start) TexOutput(">>");
2898 break;
2899 case ltSUPSET:
2900 if (start) TexOutput("{\\f1\\'C9}");
2901 break;
2902 case ltSUPSETEQ:
2903 if (start) TexOutput("{\\f1\\'CD}");
2904 break;
2905 case ltNI:
2906 if (start) TexOutput("{\\f1\\'27}");
2907 break;
2908 case ltPERP:
2909 if (start) TexOutput("{\\f1\\'5E}");
2910 break;
2911 case ltNEQ:
2912 if (start) TexOutput("{\\f1\\'B9}");
2913 break;
2914 case ltAPPROX:
2915 if (start) TexOutput("{\\f1\\'BB}");
2916 break;
2917 case ltCONG:
2918 if (start) TexOutput("{\\f1\\'40}");
2919 break;
2920 case ltEQUIV:
2921 if (start) TexOutput("{\\f1\\'BA}");
2922 break;
2923 case ltPROPTO:
2924 if (start) TexOutput("{\\f1\\'B5}");
2925 break;
2926 case ltSIM:
2927 if (start) TexOutput("{\\f1\\'7E}");
2928 break;
2929 case ltSMILE:
2930 if (start) TexOutput("{\\f4\\'4A}");
2931 break;
2932 case ltFROWN:
2933 if (start) TexOutput("{\\f4\\'4C}");
2934 break;
2935 case ltMID:
2936 if (start) TexOutput("|");
2937 break;
2938
2939 // Negated relation symbols
2940 case ltNOTEQ:
2941 if (start) TexOutput("{\\f1\\'B9}");
2942 break;
2943 case ltNOTIN:
2944 if (start) TexOutput("{\\f1\\'CF}");
2945 break;
2946 case ltNOTSUBSET:
2947 if (start) TexOutput("{\\f1\\'CB}");
2948 break;
2949
2950 // Arrows
2951 case ltLEFTARROW:
2952 if (start) TexOutput("{\\f1\\'AC}");
2953 break;
2954 case ltLEFTARROW2:
2955 if (start) TexOutput("{\\f1\\'DC}");
2956 break;
2957 case ltRIGHTARROW:
2958 if (start) TexOutput("{\\f1\\'AE}");
2959 break;
2960 case ltRIGHTARROW2:
2961 if (start) TexOutput("{\\f1\\'DE}");
2962 break;
2963 case ltLEFTRIGHTARROW:
2964 if (start) TexOutput("{\\f1\\'AB}");
2965 break;
2966 case ltLEFTRIGHTARROW2:
2967 if (start) TexOutput("{\\f1\\'DB}");
2968 break;
2969 case ltUPARROW:
2970 if (start) TexOutput("{\\f1\\'AD}");
2971 break;
2972 case ltUPARROW2:
2973 if (start) TexOutput("{\\f1\\'DD}");
2974 break;
2975 case ltDOWNARROW:
2976 if (start) TexOutput("{\\f1\\'AF}");
2977 break;
2978 case ltDOWNARROW2:
2979 if (start) TexOutput("{\\f1\\'DF}");
2980 break;
2981
2982 // Miscellaneous symbols
2983 case ltALEPH:
2984 if (start) TexOutput("{\\f1\\'CO}");
2985 break;
2986 case ltWP:
2987 if (start) TexOutput("{\\f1\\'C3}");
2988 break;
2989 case ltRE:
2990 if (start) TexOutput("{\\f1\\'C2}");
2991 break;
2992 case ltIM:
2993 if (start) TexOutput("{\\f1\\'C1}");
2994 break;
2995 case ltEMPTYSET:
2996 if (start) TexOutput("{\\f1\\'C6}");
2997 break;
2998 case ltNABLA:
2999 if (start) TexOutput("{\\f1\\'D1}");
3000 break;
3001 case ltSURD:
3002 if (start) TexOutput("{\\f1\\'D6}");
3003 break;
3004 case ltPARTIAL:
3005 if (start) TexOutput("{\\f1\\'B6}");
3006 break;
3007 case ltBOT:
3008 if (start) TexOutput("{\\f1\\'5E}");
3009 break;
3010 case ltFORALL:
3011 if (start) TexOutput("{\\f1\\'22}");
3012 break;
3013 case ltEXISTS:
3014 if (start) TexOutput("{\\f1\\'24}");
3015 break;
3016 case ltNEG:
3017 if (start) TexOutput("{\\f1\\'D8}");
3018 break;
3019 case ltSHARP:
3020 if (start) TexOutput("{\\f1\\'23}");
3021 break;
3022 case ltANGLE:
3023 if (start) TexOutput("{\\f1\\'D0}");
3024 break;
3025 case ltTRIANGLE:
3026 if (start) TexOutput("{\\f5\\'73}");
3027 break;
3028 case ltCLUBSUIT:
3029 if (start) TexOutput("{\\f5\\'A8}");
3030 break;
3031 case ltDIAMONDSUIT:
3032 if (start) TexOutput("{\\f5\\'A9}");
3033 break;
3034 case ltHEARTSUIT:
3035 if (start) TexOutput("{\\f5\\'AA}");
3036 break;
3037 case ltSPADESUIT:
3038 if (start) TexOutput("{\\f5\\'AB}");
3039 break;
3040 case ltINFTY:
3041 if (start) TexOutput("{\\f1\\'A5}");
3042 break;
3043 case ltCOPYRIGHT:
3044 if (start) TexOutput("{\\f0\\'A9}");
3045 break;
3046 case ltREGISTERED:
3047 if (start) TexOutput("{\\f0\\'AE}");
3048 break;
3049 case ltPM:
3050 if (start) TexOutput("{\\f1\\'B1}");
3051 break;
3052 case ltMP:
3053 if (start) TexOutput("{\\f1\\'B1}");
3054 break;
3055 case ltTIMES:
3056 if (start) TexOutput("{\\f1\\'B4}");
3057 break;
3058 case ltDIV:
3059 if (start) TexOutput("{\\f1\\'B8}");
3060 break;
3061 case ltCDOT:
3062 if (start) TexOutput("{\\f1\\'D7}");
3063 break;
3064 case ltAST:
3065 if (start) TexOutput("{\\f1\\'2A}");
3066 break;
3067 case ltSTAR:
3068 if (start) TexOutput("{\\f5\\'AB}");
3069 break;
3070 case ltCAP:
3071 if (start) TexOutput("{\\f1\\'C7}");
3072 break;
3073 case ltCUP:
3074 if (start) TexOutput("{\\f1\\'C8}");
3075 break;
3076 case ltVEE:
3077 if (start) TexOutput("{\\f1\\'DA}");
3078 break;
3079 case ltWEDGE:
3080 if (start) TexOutput("{\\f1\\'D9}");
3081 break;
3082 case ltCIRC:
3083 if (start) TexOutput("{\\f1\\'B0}");
3084 break;
3085 case ltBULLET:
3086 if (start) TexOutput("{\\f1\\'B7}");
3087 break;
3088 case ltDIAMOND:
3089 if (start) TexOutput("{\\f1\\'E0}");
3090 break;
3091 case ltBOX:
3092 if (start) TexOutput("{\\f1\\'C6}");
3093 break;
3094 case ltDIAMOND2:
3095 if (start) TexOutput("{\\f1\\'E0}");
3096 break;
3097 case ltBIGTRIANGLEDOWN:
3098 if (start) TexOutput("{\\f1\\'D1}");
3099 break;
3100 case ltOPLUS:
3101 if (start) TexOutput("{\\f1\\'C5}");
3102 break;
3103 case ltOTIMES:
3104 if (start) TexOutput("{\\f1\\'C4}");
3105 break;
3106 case ltSS:
3107 if (start) TexOutput("{\\'DF}");
3108 break;
3109 case ltFIGURE:
3110 {
3111 if (start) inFigure = TRUE;
3112 else inFigure = FALSE;
3113 break;
3114 }
3115 case ltTABLE:
3116 {
3117 if (start) inTable = TRUE;
3118 else inTable = FALSE;
3119 break;
3120 }
3121 default:
3122 {
3123 DefaultOnMacro(macroId, no_args, start);
3124 break;
3125 }
3126 }
3127 }
3128
3129 // Called on start/end of argument examination
3130 bool RTFOnArgument(int macroId, int arg_no, bool start)
3131 {
3132 char buf[300];
3133 switch (macroId)
3134 {
3135 case ltCHAPTER:
3136 case ltCHAPTERSTAR:
3137 case ltCHAPTERHEADING:
3138 case ltSECTION:
3139 case ltSECTIONSTAR:
3140 case ltSECTIONHEADING:
3141 case ltSUBSECTION:
3142 case ltSUBSECTIONSTAR:
3143 case ltSUBSUBSECTION:
3144 case ltSUBSUBSECTIONSTAR:
3145 case ltGLOSS:
3146 case ltMEMBERSECTION:
3147 case ltFUNCTIONSECTION:
3148 case ltCAPTION:
3149 case ltCAPTIONSTAR:
3150 {
3151 if (!start && (arg_no == 1))
3152 currentSection = GetArgChunk();
3153 return FALSE;
3154 break;
3155 }
3156 case ltFUNC:
3157 {
3158 if (start && (arg_no == 1))
3159 TexOutput("\\pard\\li600\\fi-600{\\b ");
3160
3161 if (!start && (arg_no == 1))
3162 TexOutput("} ");
3163
3164 if (start && (arg_no == 2))
3165 {
3166 if (!suppressNameDecoration) TexOutput("{\\b ");
3167 currentMember = GetArgChunk();
3168 }
3169 if (!start && (arg_no == 2))
3170 {
3171 if (!suppressNameDecoration) TexOutput("}");
3172 }
3173
3174 if (start && (arg_no == 3))
3175 TexOutput("(");
3176 if (!start && (arg_no == 3))
3177 {
3178 // TexOutput(")\\li0\\fi0");
3179 // TexOutput(")\\par\\pard\\li0\\fi0");
3180 // issuedNewParagraph = 1;
3181 TexOutput(")");
3182 WriteEnvironmentStyles();
3183 }
3184 break;
3185 }
3186 case ltCLIPSFUNC:
3187 {
3188 if (start && (arg_no == 1))
3189 TexOutput("\\pard\\li260\\fi-260{\\b ");
3190 if (!start && (arg_no == 1))
3191 TexOutput("} ");
3192
3193 if (start && (arg_no == 2))
3194 {
3195 if (!suppressNameDecoration) TexOutput("({\\b ");
3196 currentMember = GetArgChunk();
3197 }
3198 if (!start && (arg_no == 2))
3199 {
3200 if (!suppressNameDecoration) TexOutput("}");
3201 }
3202
3203 if (!start && (arg_no == 3))
3204 {
3205 TexOutput(")\\li0\\fi0");
3206 WriteEnvironmentStyles();
3207 }
3208 break;
3209 }
3210 case ltPFUNC:
3211 {
3212 if (start && (arg_no == 1))
3213 TexOutput("\\pard\\li260\\fi-260");
3214
3215 if (!start && (arg_no == 1))
3216 TexOutput(" ");
3217
3218 if (start && (arg_no == 2))
3219 TexOutput("(*");
3220 if (!start && (arg_no == 2))
3221 TexOutput(")");
3222
3223 if (start && (arg_no == 2))
3224 currentMember = GetArgChunk();
3225
3226 if (start && (arg_no == 3))
3227 TexOutput("(");
3228 if (!start && (arg_no == 3))
3229 {
3230 TexOutput(")\\li0\\fi0");
3231 WriteEnvironmentStyles();
3232 }
3233 break;
3234 }
3235 case ltPARAM:
3236 {
3237 if (start && (arg_no == 1))
3238 TexOutput("{\\b ");
3239 if (!start && (arg_no == 1))
3240 TexOutput("}");
3241 if (start && (arg_no == 2))
3242 {
3243 TexOutput("{\\i ");
3244 }
3245 if (!start && (arg_no == 2))
3246 {
3247 TexOutput("}");
3248 }
3249 break;
3250 }
3251 case ltCPARAM:
3252 {
3253 if (start && (arg_no == 1))
3254 TexOutput("{\\b ");
3255 if (!start && (arg_no == 1))
3256 TexOutput("} "); // This is the difference from param - one space!
3257 if (start && (arg_no == 2))
3258 {
3259 TexOutput("{\\i ");
3260 }
3261 if (!start && (arg_no == 2))
3262 {
3263 TexOutput("}");
3264 }
3265 break;
3266 }
3267 case ltMEMBER:
3268 {
3269 if (!start && (arg_no == 1))
3270 TexOutput(" ");
3271
3272 if (start && (arg_no == 2))
3273 currentMember = GetArgChunk();
3274 break;
3275 }
3276 case ltREF:
3277 {
3278 if (start)
3279 {
3280 char *sec = NULL;
3281 char *secName = NULL;
3282
3283 char *refName = GetArgData();
3284 if (winHelp || !useWord)
3285 {
3286 if (refName)
3287 {
3288 TexRef *texRef = FindReference(refName);
3289 if (texRef)
3290 {
3291 sec = texRef->sectionNumber;
3292 secName = texRef->sectionName;
3293 }
3294 }
3295 if (sec)
3296 {
3297 TexOutput(sec);
3298 }
3299 }
3300 else
3301 {
3302 fprintf(Chapters, "{\\field{\\*\\fldinst REF %s \\\\* MERGEFORMAT }{\\fldrslt ??}}",
3303 refName);
3304 }
3305 return FALSE;
3306 }
3307 break;
3308 }
3309 case ltHELPREF:
3310 case ltHELPREFN:
3311 {
3312 if (winHelp)
3313 {
3314 if ((GetNoArgs() - arg_no) == 1)
3315 {
3316 if (start)
3317 TexOutput("{\\uldb ");
3318 else
3319 TexOutput("}");
3320 }
3321 if ((GetNoArgs() - arg_no) == 0) // Arg = 2, or 3 if first is optional
3322 {
3323 if (start)
3324 {
3325 TexOutput("{\\v ");
3326
3327 // Remove green colour/underlining if specified
3328 if (!hotSpotUnderline && !hotSpotColour)
3329 TexOutput("%");
3330 else if (!hotSpotColour)
3331 TexOutput("*");
3332 }
3333 else TexOutput("}");
3334 }
3335 }
3336 else // If a linear document, must resolve the references ourselves
3337 {
3338 if ((GetNoArgs() - arg_no) == 1)
3339 {
3340 // In a linear document we display the anchor text in italic plus
3341 // the page number.
3342 if (start)
3343 TexOutput("{\\i ");
3344 else
3345 TexOutput("}");
3346
3347 if (start)
3348 helpRefText = GetArgChunk();
3349
3350 return TRUE;
3351 }
3352 else if ((GetNoArgs() - arg_no) == 0) // Arg = 2, or 3 if first is optional
3353 {
3354 if (macroId != ltHELPREFN)
3355 {
3356 char *refName = GetArgData();
3357 TexRef *texRef = NULL;
3358 if (refName)
3359 texRef = FindReference(refName);
3360 if (start)
3361 {
3362 if (texRef || !ignoreBadRefs)
3363 TexOutput(" (");
3364 if (refName)
3365 {
3366 if (texRef || !ignoreBadRefs)
3367 {
3368 if (useWord)
3369 {
3370 char *s = GetArgData();
3371 TexOutput("p. ");
3372 TexOutput("{\\field{\\*\\fldinst PAGEREF ");
3373 TexOutput(refName);
3374 TexOutput(" \\\\* MERGEFORMAT }{\\fldrslt ??}}");
3375 }
3376 else
3377 {
3378 // Only print section name if we're not in Word mode,
3379 // so can't do page references
3380 if (texRef)
3381 {
3382 TexOutput(texRef->sectionName) ; TexOutput(" "); TexOutput(texRef->sectionNumber);
3383 }
3384 else
3385 {
3386 if (!ignoreBadRefs)
3387 TexOutput("??");
3388 sprintf(buf, "Warning: unresolved reference '%s'", refName);
3389 OnInform(buf);
3390 }
3391 }
3392 }
3393 }
3394 else TexOutput("??");
3395 }
3396 else
3397 {
3398 if (texRef || !ignoreBadRefs)
3399 TexOutput(")");
3400 }
3401 }
3402 return FALSE;
3403 }
3404 }
3405 break;
3406 }
3407 case ltURLREF:
3408 {
3409 if (arg_no == 1)
3410 {
3411 return TRUE;
3412 }
3413 else if (arg_no == 2)
3414 {
3415 if (start)
3416 {
3417 inVerbatim = TRUE;
3418 TexOutput(" ({\\f3 ");
3419 }
3420 else
3421 {
3422 TexOutput("})");
3423 inVerbatim = FALSE;
3424 }
3425 return TRUE;
3426 }
3427 break;
3428 }
3429 case ltPOPREF:
3430 {
3431 if (winHelp)
3432 {
3433 if ((GetNoArgs() - arg_no) == 1)
3434 {
3435 if (start)
3436 TexOutput("{\\ul ");
3437 else
3438 TexOutput("}");
3439 }
3440 if ((GetNoArgs() - arg_no) == 0) // Arg = 2, or 3 if first is optional
3441 {
3442 if (start)
3443 {
3444 TexOutput("{\\v ");
3445
3446 // Remove green colour/underlining if specified
3447 if (!hotSpotUnderline && !hotSpotColour)
3448 TexOutput("%");
3449 else if (!hotSpotColour)
3450 TexOutput("*");
3451 }
3452 else TexOutput("}");
3453 }
3454 }
3455 else // A linear document...
3456 {
3457 if ((GetNoArgs() - arg_no) == 1)
3458 {
3459 // In a linear document we just display the anchor text in italic
3460 if (start)
3461 TexOutput("{\\i ");
3462 else
3463 TexOutput("}");
3464 return TRUE;
3465 }
3466 else return FALSE;
3467 }
3468 break;
3469 }
3470 case ltADDCONTENTSLINE:
3471 {
3472 if (start && !winHelp)
3473 {
3474 if (arg_no == 2)
3475 contentsLineSection = copystring(GetArgData());
3476 else if (arg_no == 3)
3477 contentsLineValue = copystring(GetArgData());
3478 return FALSE;
3479 }
3480 else return FALSE;
3481 break;
3482 }
3483 case ltIMAGE:
3484 case ltIMAGEL:
3485 case ltIMAGER:
3486 case ltIMAGEMAP:
3487 case ltPSBOXTO:
3488 {
3489 if (arg_no == 3)
3490 return FALSE;
3491
3492 static int imageWidth = 0;
3493 static int imageHeight = 0;
3494
3495 if (start && (arg_no == 1))
3496 {
3497 char *imageDimensions = copystring(GetArgData());
3498 char buf1[50];
3499 strcpy(buf1, imageDimensions);
3500 char *tok1 = strtok(buf1, ";:");
3501 char *tok2 = strtok(NULL, ";:");
3502 // Convert points to TWIPS (1 twip = 1/20th of point)
3503 imageWidth = (int)(20*(tok1 ? ParseUnitArgument(tok1) : 0));
3504 imageHeight = (int)(20*(tok2 ? ParseUnitArgument(tok2) : 0));
3505 if (imageDimensions) // glt
3506 delete [] imageDimensions;
3507 return FALSE;
3508 }
3509 else if (start && (arg_no == 2 ))
3510 {
3511 char *filename = copystring(GetArgData());
3512 wxString f = "";
3513 if ((winHelp || (strcmp(bitmapMethod, "includepicture") == 0) || (strcmp(bitmapMethod, "import") == 0)) && useWord)
3514 {
3515 if (f == "") // Try for a .shg (segmented hypergraphics file)
3516 {
3517 strcpy(buf, filename);
3518 StripExtension(buf);
3519 strcat(buf, ".shg");
3520 f = TexPathList.FindValidPath(buf);
3521 }
3522 if (f == "") // Try for a .bmp
3523 {
3524 strcpy(buf, filename);
3525 StripExtension(buf);
3526 strcat(buf, ".bmp");
3527 f = TexPathList.FindValidPath(buf);
3528 }
3529 if (f == "") // Try for a metafile instead
3530 {
3531 strcpy(buf, filename);
3532 StripExtension(buf);
3533 strcat(buf, ".wmf");
3534 f = TexPathList.FindValidPath(buf);
3535 }
3536 if (f != "")
3537 {
3538 if (winHelp)
3539 {
3540 if (bitmapTransparency && (winHelpVersion > 3))
3541 TexOutput("\\{bmct ");
3542 else
3543 TexOutput("\\{bmc ");
3544 wxString str = wxFileNameFromPath(f);
3545 TexOutput((char*) (const char*) str);
3546 TexOutput("\\}");
3547 }
3548 else
3549 {
3550 // Microsoft Word method
3551 if (strcmp(bitmapMethod, "import") == 0)
3552 TexOutput("{\\field{\\*\\fldinst IMPORT ");
3553 else
3554 TexOutput("{\\field{\\*\\fldinst INCLUDEPICTURE ");
3555
3556 // Full path appears not to be valid!
3557 wxString str = wxFileNameFromPath(f);
3558 TexOutput((char*)(const char*) str);
3559 /*
3560 int len = strlen(f);
3561 char smallBuf[2]; smallBuf[1] = 0;
3562 for (int i = 0; i < len; i++)
3563 {
3564 smallBuf[0] = f[i];
3565 TexOutput(smallBuf);
3566 if (smallBuf[0] == '\\')
3567 TexOutput(smallBuf);
3568 }
3569 */
3570 TexOutput("}{\\fldrslt PRESS F9 TO FORMAT PICTURE}}");
3571 }
3572 }
3573 else
3574 {
3575 TexOutput("[No BMP or WMF for image file ");
3576 TexOutput(filename);
3577 TexOutput("]");
3578 sprintf(buf, "Warning: could not find a BMP or WMF equivalent for %s.", filename);
3579 OnInform(buf);
3580 }
3581 if (filename) // glt
3582 delete [] filename;
3583 }
3584 else // linear RTF
3585 {
3586 if (f == "") // Try for a .bmp
3587 {
3588 strcpy(buf, filename);
3589 StripExtension(buf);
3590 strcat(buf, ".bmp");
3591 f = TexPathList.FindValidPath(buf);
3592 }
3593 if (f != "")
3594 {
3595 FILE *fd = fopen(f, "rb");
3596 if (OutputBitmapHeader(fd, winHelp))
3597 OutputBitmapData(fd);
3598 else
3599 {
3600 sprintf(buf, "Could not read bitmap %s.\nMay be in wrong format (needs RGB-encoded Windows BMP).", (const char*) f);
3601 OnError(buf);
3602 }
3603 fclose(fd);
3604 }
3605 else // Try for a metafile instead
3606 {
3607 #ifdef __WXMSW__
3608 strcpy(buf, filename);
3609 StripExtension(buf);
3610 strcat(buf, ".wmf");
3611 f = TexPathList.FindValidPath(buf);
3612 if (f != "")
3613 {
3614 // HFILE handle = _lopen(f, READ);
3615 FILE *fd = fopen(f, "rb");
3616 if (OutputMetafileHeader(fd, winHelp, imageWidth, imageHeight))
3617 {
3618 OutputMetafileData(fd);
3619 }
3620 else
3621 {
3622 sprintf(buf, "Could not read metafile %s. Perhaps it's not a placeable metafile?", f);
3623 OnError(buf);
3624 }
3625 fclose(fd);
3626 }
3627 else
3628 {
3629 #endif
3630 TexOutput("[No BMP or WMF for image file ");
3631 TexOutput(filename);
3632 TexOutput("]");
3633 sprintf(buf, "Warning: could not find a BMP or WMF equivalent for %s.", filename);
3634 OnInform(buf);
3635 #ifdef __WXMSW__
3636 }
3637 #endif
3638 }
3639 }
3640 return FALSE;
3641 }
3642 else
3643 return FALSE;
3644 break;
3645 }
3646 case ltTABULAR:
3647 case ltSUPERTABULAR:
3648 {
3649 if (arg_no == 1)
3650 {
3651 if (start)
3652 {
3653 currentRowNumber = 0;
3654 inTabular = TRUE;
3655 startRows = TRUE;
3656 tableVerticalLineLeft = FALSE;
3657 tableVerticalLineRight = FALSE;
3658 int currentWidth = 0;
3659
3660 char *alignString = copystring(GetArgData());
3661 ParseTableArgument(alignString);
3662
3663 // TexOutput("\\trowd\\trgaph108\\trleft-108");
3664 TexOutput("\\trowd\\trgaph108");
3665
3666 // Write the first row formatting for compatibility
3667 // with standard Latex
3668 if (compatibilityMode)
3669 {
3670 for (int i = 0; i < noColumns; i++)
3671 {
3672 currentWidth += TableData[i].width;
3673 sprintf(buf, "\\cellx%d", currentWidth);
3674 TexOutput(buf);
3675 }
3676 TexOutput("\\pard\\intbl\n");
3677 }
3678 delete[] alignString;
3679
3680 return FALSE;
3681 }
3682 }
3683 else if (arg_no == 2 && !start)
3684 {
3685 TexOutput("\\pard\n");
3686 WriteEnvironmentStyles();
3687 inTabular = FALSE;
3688 }
3689 break;
3690 }
3691
3692 case ltQUOTE:
3693 case ltVERSE:
3694 {
3695 if (start)
3696 {
3697 TexOutput("\\li360\n");
3698 forbidParindent ++;
3699 PushEnvironmentStyle("\\li360");
3700 }
3701 else
3702 {
3703 forbidParindent --;
3704 PopEnvironmentStyle();
3705 OnMacro(ltPAR, 0, TRUE);
3706 OnMacro(ltPAR, 0, FALSE);
3707 }
3708 break;
3709 }
3710 case ltQUOTATION:
3711 {
3712 if (start)
3713 {
3714 TexOutput("\\li360\n");
3715 PushEnvironmentStyle("\\li360");
3716 }
3717 else
3718 {
3719 PopEnvironmentStyle();
3720 OnMacro(ltPAR, 0, TRUE);
3721 OnMacro(ltPAR, 0, FALSE);
3722 }
3723 break;
3724 }
3725 case ltBOXIT:
3726 case ltFRAMEBOX:
3727 case ltFBOX:
3728 case ltNORMALBOX:
3729 case ltNORMALBOXD:
3730 {
3731 if (start)
3732 {
3733 sprintf(buf, "\\box\\trgaph108%s\n", ((macroId == ltNORMALBOXD) ? "\\brdrdb" : "\\brdrs"));
3734 TexOutput(buf);
3735 PushEnvironmentStyle(buf);
3736 }
3737 else
3738 {
3739 PopEnvironmentStyle();
3740 OnMacro(ltPAR, 0, TRUE);
3741 OnMacro(ltPAR, 0, FALSE);
3742 }
3743 break;
3744 }
3745 case ltHELPFONTSIZE:
3746 {
3747 if (start)
3748 {
3749 char *data = GetArgData();
3750 if (strcmp(data, "10") == 0)
3751 SetFontSizes(10);
3752 else if (strcmp(data, "11") == 0)
3753 SetFontSizes(11);
3754 else if (strcmp(data, "12") == 0)
3755 SetFontSizes(12);
3756 sprintf(buf, "\\fs%d\n", normalFont*2);
3757 TexOutput(buf);
3758 TexOutput(buf);
3759 return FALSE;
3760 }
3761 break;
3762 }
3763 case ltHELPFONTFAMILY:
3764 {
3765 if (start)
3766 {
3767 char *data = GetArgData();
3768 if (strcmp(data, "Swiss") == 0)
3769 TexOutput("\\f2\n");
3770 else if (strcmp(data, "Symbol") == 0)
3771 TexOutput("\\f1\n");
3772 else if (strcmp(data, "Times") == 0)
3773 TexOutput("\\f0\n");
3774
3775 return FALSE;
3776 }
3777 break;
3778 }
3779 case ltPARINDENT:
3780 {
3781 if (start && arg_no == 1)
3782 {
3783 char *data = GetArgData();
3784 ParIndent = ParseUnitArgument(data);
3785 if (ParIndent == 0 || forbidParindent == 0)
3786 {
3787 sprintf(buf, "\\fi%d\n", ParIndent*20);
3788 TexOutput(buf);
3789 }
3790 return FALSE;
3791 }
3792 break;
3793 }
3794 case ltITEM:
3795 {
3796 if (start && IsArgOptional())
3797 {
3798 descriptionItemArg = GetArgChunk();
3799 return FALSE;
3800 }
3801 break;
3802 }
3803 case ltTWOCOLITEM:
3804 case ltTWOCOLITEMRULED:
3805 {
3806 switch (arg_no)
3807 {
3808 case 1:
3809 {
3810 if (!start)
3811 TexOutput("\\tab ");
3812 break;
3813 }
3814 case 2:
3815 {
3816 if (!start)
3817 {
3818 if (macroId == ltTWOCOLITEMRULED)
3819 TexOutput("\\brdrb\\brdrs\\brdrw15\\brsp20 ");
3820 TexOutput("\\par\\pard\n");
3821 issuedNewParagraph = 1;
3822 WriteEnvironmentStyles();
3823 }
3824 break;
3825 }
3826 }
3827 return TRUE;
3828 break;
3829 }
3830 /*
3831 * Accents
3832 *
3833 */
3834 case ltACCENT_GRAVE:
3835 {
3836 if (start)
3837 {
3838 char *val = GetArgData();
3839 if (val)
3840 {
3841 switch (val[0])
3842 {
3843 case 'a':
3844 TexOutput("\\'e0");
3845 break;
3846 case 'e':
3847 TexOutput("\\'e8");
3848 break;
3849 case 'i':
3850 TexOutput("\\'ec");
3851 break;
3852 case 'o':
3853 TexOutput("\\'f2");
3854 break;
3855 case 'u':
3856 TexOutput("\\'f9");
3857 break;
3858 case 'A':
3859 TexOutput("\\'c0");
3860 break;
3861 case 'E':
3862 TexOutput("\\'c8");
3863 break;
3864 case 'I':
3865 TexOutput("\\'cc");
3866 break;
3867 case 'O':
3868 TexOutput("\\'d2");
3869 break;
3870 case 'U':
3871 TexOutput("\\'d9");
3872 break;
3873 default:
3874 break;
3875 }
3876 }
3877 }
3878 return FALSE;
3879 break;
3880 }
3881 case ltACCENT_ACUTE:
3882 {
3883 if (start)
3884 {
3885 char *val = GetArgData();
3886 if (val)
3887 {
3888 switch (val[0])
3889 {
3890 case 'a':
3891 TexOutput("\\'e1");
3892 break;
3893 case 'e':
3894 TexOutput("\\'e9");
3895 break;
3896 case 'i':
3897 TexOutput("\\'ed");
3898 break;
3899 case 'o':
3900 TexOutput("\\'f3");
3901 break;
3902 case 'u':
3903 TexOutput("\\'fa");
3904 break;
3905 case 'y':
3906 TexOutput("\\'fd");
3907 break;
3908 case 'A':
3909 TexOutput("\\'c1");
3910 break;
3911 case 'E':
3912 TexOutput("\\'c9");
3913 break;
3914 case 'I':
3915 TexOutput("\\'cd");
3916 break;
3917 case 'O':
3918 TexOutput("\\'d3");
3919 break;
3920 case 'U':
3921 TexOutput("\\'da");
3922 break;
3923 case 'Y':
3924 TexOutput("\\'dd");
3925 break;
3926 default:
3927 break;
3928 }
3929 }
3930 }
3931 return FALSE;
3932 break;
3933 }
3934 case ltACCENT_CARET:
3935 {
3936 if (start)
3937 {
3938 char *val = GetArgData();
3939 if (val)
3940 {
3941 switch (val[0])
3942 {
3943 case 'a':
3944 TexOutput("\\'e2");
3945 break;
3946 case 'e':
3947 TexOutput("\\'ea");
3948 break;
3949 case 'i':
3950 TexOutput("\\'ee");
3951 break;
3952 case 'o':
3953 TexOutput("\\'f4");
3954 break;
3955 case 'u':
3956 TexOutput("\\'fb");
3957 break;
3958 case 'A':
3959 TexOutput("\\'c2");
3960 break;
3961 case 'E':
3962 TexOutput("\\'ca");
3963 break;
3964 case 'I':
3965 TexOutput("\\'ce");
3966 break;
3967 case 'O':
3968 TexOutput("\\'d4");
3969 break;
3970 case 'U':
3971 TexOutput("\\'db");
3972 break;
3973 default:
3974 break;
3975 }
3976 }
3977 }
3978 return FALSE;
3979 break;
3980 }
3981 case ltACCENT_TILDE:
3982 {
3983 if (start)
3984 {
3985 char *val = GetArgData();
3986 if (val)
3987 {
3988 switch (val[0])
3989 {
3990 case 'a':
3991 TexOutput("\\'e3");
3992 break;
3993 case ' ':
3994 TexOutput("~");
3995 break;
3996 case 'n':
3997 TexOutput("\\'f1");
3998 break;
3999 case 'o':
4000 TexOutput("\\'f5");
4001 break;
4002 case 'A':
4003 TexOutput("\\'c3");
4004 break;
4005 case 'N':
4006 TexOutput("\\'d1");
4007 break;
4008 case 'O':
4009 TexOutput("\\'d5");
4010 break;
4011 default:
4012 break;
4013 }
4014 }
4015 }
4016 return FALSE;
4017 break;
4018 }
4019 case ltACCENT_UMLAUT:
4020 {
4021 if (start)
4022 {
4023 char *val = GetArgData();
4024 if (val)
4025 {
4026 switch (val[0])
4027 {
4028 case 'a':
4029 TexOutput("\\'e4");
4030 break;
4031 case 'e':
4032 TexOutput("\\'eb");
4033 break;
4034 case 'i':
4035 TexOutput("\\'ef");
4036 break;
4037 case 'o':
4038 TexOutput("\\'f6");
4039 break;
4040 case 'u':
4041 TexOutput("\\'fc");
4042 break;
4043 case 's':
4044 TexOutput("\\'df");
4045 break;
4046 case 'y':
4047 TexOutput("\\'ff");
4048 break;
4049 case 'A':
4050 TexOutput("\\'c4");
4051 break;
4052 case 'E':
4053 TexOutput("\\'cb");
4054 break;
4055 case 'I':
4056 TexOutput("\\'cf");
4057 break;
4058 case 'O':
4059 TexOutput("\\'d6");
4060 break;
4061 case 'U':
4062 TexOutput("\\'dc");
4063 break;
4064 case 'Y':
4065 TexOutput("\\'df");
4066 break;
4067 default:
4068 break;
4069 }
4070 }
4071 }
4072 return FALSE;
4073 break;
4074 }
4075 case ltACCENT_DOT:
4076 {
4077 if (start)
4078 {
4079 char *val = GetArgData();
4080 if (val)
4081 {
4082 switch (val[0])
4083 {
4084 case 'a':
4085 TexOutput("\\'e5");
4086 break;
4087 case 'A':
4088 TexOutput("\\'c5");
4089 break;
4090 default:
4091 break;
4092 }
4093 }
4094 }
4095 return FALSE;
4096 break;
4097 }
4098 case ltACCENT_CADILLA:
4099 {
4100 if (start)
4101 {
4102 char *val = GetArgData();
4103 if (val)
4104 {
4105 switch (val[0])
4106 {
4107 case 'c':
4108 TexOutput("\\'e7");
4109 break;
4110 case 'C':
4111 TexOutput("\\'c7");
4112 break;
4113 default:
4114 break;
4115 }
4116 }
4117 }
4118 return FALSE;
4119 break;
4120 }
4121 case ltFOOTNOTE:
4122 {
4123 static char *helpTopic = NULL;
4124 static FILE *savedOutput = NULL;
4125 if (winHelp)
4126 {
4127 if (arg_no == 1)
4128 {
4129 if (start)
4130 {
4131 OnInform("Consider using \\footnotepopup instead of \\footnote.");
4132 footnoteCount ++;
4133 char footBuf[20];
4134 sprintf(footBuf, "(%d)", footnoteCount);
4135
4136 TexOutput(" {\\ul ");
4137 TexOutput(footBuf);
4138 TexOutput("}");
4139 helpTopic = FindTopicName(NULL);
4140 TexOutput("{\\v ");
4141
4142 // Remove green colour/underlining if specified
4143 if (!hotSpotUnderline && !hotSpotColour)
4144 TexOutput("%");
4145 else if (!hotSpotColour)
4146 TexOutput("*");
4147
4148 TexOutput(helpTopic);
4149 TexOutput("}");
4150
4151 fprintf(Popups, "\\page\n");
4152 // fprintf(Popups, "\n${\\footnote }"); // No title
4153 fprintf(Popups, "\n#{\\footnote %s}\n", helpTopic);
4154 fprintf(Popups, "+{\\footnote %s}\n", GetBrowseString());
4155 savedOutput = CurrentOutput1;
4156 SetCurrentOutput(Popups);
4157 }
4158 else
4159 {
4160 SetCurrentOutput(savedOutput);
4161 }
4162 return TRUE;
4163 }
4164 return TRUE;
4165 }
4166 else
4167 {
4168 if (start)
4169 {
4170 TexOutput(" {\\super \\chftn{\\footnote \\fs20 {\\super \\chftn}", TRUE);
4171 }
4172 else
4173 {
4174 TexOutput("}}", TRUE);
4175 }
4176 return TRUE;
4177 }
4178 break;
4179 }
4180 case ltFOOTNOTEPOPUP:
4181 {
4182 static char *helpTopic = NULL;
4183 static FILE *savedOutput = NULL;
4184 if (winHelp)
4185 {
4186 if (arg_no == 1)
4187 {
4188 if (start)
4189 {
4190 TexOutput("{\\ul ");
4191 }
4192 else TexOutput("}");
4193 return TRUE;
4194 }
4195 else if (arg_no == 2)
4196 {
4197 if (start)
4198 {
4199 helpTopic = FindTopicName(NULL);
4200 TexOutput("{\\v ");
4201
4202 // Remove green colour/underlining if specified
4203 if (!hotSpotUnderline && !hotSpotColour)
4204 TexOutput("%");
4205 else if (!hotSpotColour)
4206 TexOutput("*");
4207
4208 TexOutput(helpTopic);
4209 TexOutput("}");
4210
4211 fprintf(Popups, "\\page\n");
4212 // fprintf(Popups, "\n${\\footnote }"); // No title
4213 fprintf(Popups, "\n#{\\footnote %s}\n", helpTopic);
4214 fprintf(Popups, "+{\\footnote %s}\n", GetBrowseString());
4215 savedOutput = CurrentOutput1;
4216 SetCurrentOutput(Popups);
4217 }
4218 else
4219 {
4220 SetCurrentOutput(savedOutput);
4221 }
4222 return TRUE;
4223 }
4224 }
4225 else
4226 {
4227 if (arg_no == 1)
4228 return TRUE;
4229 if (start)
4230 {
4231 TexOutput(" {\\super \\chftn{\\footnote \\fs20 {\\super \\chftn}", TRUE);
4232 }
4233 else
4234 {
4235 TexOutput("}}", TRUE);
4236 }
4237 return TRUE;
4238 }
4239 break;
4240 }
4241 case ltFANCYPLAIN:
4242 {
4243 if (start && (arg_no == 1))
4244 return FALSE;
4245 else
4246 return TRUE;
4247 break;
4248 }
4249 case ltSETHEADER:
4250 {
4251 if (start)
4252 forbidResetPar ++;
4253 else
4254 forbidResetPar --;
4255
4256 if (winHelp) return FALSE;
4257 if (start)
4258 {
4259 switch (arg_no)
4260 {
4261 case 1:
4262 LeftHeaderEven = GetArgChunk();
4263 if (strlen(GetArgData(LeftHeaderEven)) == 0)
4264 LeftHeaderEven = NULL;
4265 break;
4266 case 2:
4267 CentreHeaderEven = GetArgChunk();
4268 if (strlen(GetArgData(CentreHeaderEven)) == 0)
4269 CentreHeaderEven = NULL;
4270 break;
4271 case 3:
4272 RightHeaderEven = GetArgChunk();
4273 if (strlen(GetArgData(RightHeaderEven)) == 0)
4274 RightHeaderEven = NULL;
4275 break;
4276 case 4:
4277 LeftHeaderOdd = GetArgChunk();
4278 if (strlen(GetArgData(LeftHeaderOdd)) == 0)
4279 LeftHeaderOdd = NULL;
4280 break;
4281 case 5:
4282 CentreHeaderOdd = GetArgChunk();
4283 if (strlen(GetArgData(CentreHeaderOdd)) == 0)
4284 CentreHeaderOdd = NULL;
4285 break;
4286 case 6:
4287 RightHeaderOdd = GetArgChunk();
4288 if (strlen(GetArgData(RightHeaderOdd)) == 0)
4289 RightHeaderOdd = NULL;
4290 OutputRTFHeaderCommands();
4291 break;
4292 default:
4293 break;
4294 }
4295 }
4296 return FALSE;
4297 break;
4298 }
4299 case ltSETFOOTER:
4300 {
4301 if (start)
4302 forbidResetPar ++;
4303 else
4304 forbidResetPar --;
4305
4306 if (winHelp) return FALSE;
4307 if (start)
4308 {
4309 switch (arg_no)
4310 {
4311 case 1:
4312 LeftFooterEven = GetArgChunk();
4313 if (strlen(GetArgData(LeftFooterEven)) == 0)
4314 LeftFooterEven = NULL;
4315 break;
4316 case 2:
4317 CentreFooterEven = GetArgChunk();
4318 if (strlen(GetArgData(CentreFooterEven)) == 0)
4319 CentreFooterEven = NULL;
4320 break;
4321 case 3:
4322 RightFooterEven = GetArgChunk();
4323 if (strlen(GetArgData(RightFooterEven)) == 0)
4324 RightFooterEven = NULL;
4325 break;
4326 case 4:
4327 LeftFooterOdd = GetArgChunk();
4328 if (strlen(GetArgData(LeftFooterOdd)) == 0)
4329 LeftFooterOdd = NULL;
4330 break;
4331 case 5:
4332 CentreFooterOdd = GetArgChunk();
4333 if (strlen(GetArgData(CentreFooterOdd)) == 0)
4334 CentreFooterOdd = NULL;
4335 break;
4336 case 6:
4337 RightFooterOdd = GetArgChunk();
4338 if (strlen(GetArgData(RightFooterOdd)) == 0)
4339 RightFooterOdd = NULL;
4340 OutputRTFFooterCommands();
4341 break;
4342 default:
4343 break;
4344 }
4345 }
4346 return FALSE;
4347 break;
4348 }
4349 case ltMARKRIGHT:
4350 {
4351 if (winHelp) return FALSE;
4352 // Fake a SetHeader command
4353 if (start)
4354 {
4355 LeftHeaderOdd = NULL;
4356 CentreHeaderOdd = NULL;
4357 RightHeaderOdd = NULL;
4358 LeftHeaderEven = NULL;
4359 CentreHeaderEven = NULL;
4360 RightHeaderEven = NULL;
4361 OnInform("Consider using setheader/setfooter rather than markright.");
4362 }
4363 RTFOnArgument(ltSETHEADER, 4, start);
4364 if (!start)
4365 OutputRTFHeaderCommands();
4366 return FALSE;
4367 break;
4368 }
4369 case ltMARKBOTH:
4370 {
4371 if (winHelp) return FALSE;
4372 // Fake a SetHeader command
4373 switch (arg_no)
4374 {
4375 case 1:
4376 {
4377 if (start)
4378 {
4379 LeftHeaderOdd = NULL;
4380 CentreHeaderOdd = NULL;
4381 RightHeaderOdd = NULL;
4382 LeftHeaderEven = NULL;
4383 CentreHeaderEven = NULL;
4384 RightHeaderEven = NULL;
4385 OnInform("Consider using setheader/setfooter rather than markboth.");
4386 }
4387 return RTFOnArgument(ltSETHEADER, 1, start);
4388 break;
4389 }
4390 case 2:
4391 {
4392 RTFOnArgument(ltSETHEADER, 4, start);
4393 if (!start)
4394 OutputRTFHeaderCommands();
4395 return FALSE;
4396 break;
4397 }
4398 }
4399 break;
4400 }
4401 case ltPAGENUMBERING:
4402 {
4403 if (start)
4404 forbidResetPar ++;
4405 else
4406 forbidResetPar --;
4407
4408 if (winHelp) return FALSE;
4409 if (start)
4410 {
4411 TexOutput("\\pgnrestart");
4412 char *data = GetArgData();
4413 if (currentNumberStyle) delete[] currentNumberStyle;
4414 currentNumberStyle = copystring(data);
4415 OutputNumberStyle(currentNumberStyle);
4416
4417 TexOutput("\n");
4418 }
4419 return FALSE;
4420 break;
4421 }
4422 case ltTWOCOLUMN:
4423 {
4424 if (winHelp) return FALSE;
4425 if (start)
4426 return TRUE;
4427 break;
4428 }
4429 case ltITEMSEP:
4430 {
4431 if (start)
4432 {
4433 char *val = GetArgData();
4434 currentItemSep = ParseUnitArgument(val);
4435 return FALSE;
4436 }
4437 break;
4438 }
4439 case ltEVENSIDEMARGIN:
4440 {
4441 return FALSE;
4442 break;
4443 }
4444 case ltODDSIDEMARGIN:
4445 {
4446 if (start)
4447 {
4448 char *val = GetArgData();
4449 int twips = (int)(20*ParseUnitArgument(val));
4450 // Add an inch since in LaTeX it's specified minus an inch
4451 twips += 1440;
4452 CurrentLeftMarginOdd = twips;
4453 sprintf(buf, "\\margl%d\n", twips);
4454 TexOutput(buf);
4455
4456 CurrentMarginParX = CurrentLeftMarginOdd + CurrentTextWidth + CurrentMarginParSep;
4457 }
4458 return FALSE;
4459 }
4460 case ltMARGINPARWIDTH:
4461 {
4462 if (start)
4463 {
4464 char *val = GetArgData();
4465 int twips = (int)(20*ParseUnitArgument(val));
4466 CurrentMarginParWidth = twips;
4467 }
4468 return FALSE;
4469 }
4470 case ltMARGINPARSEP:
4471 {
4472 if (start)
4473 {
4474 char *val = GetArgData();
4475 int twips = (int)(20*ParseUnitArgument(val));
4476 CurrentMarginParSep = twips;
4477 CurrentMarginParX = CurrentLeftMarginOdd + CurrentTextWidth + CurrentMarginParSep;
4478 }
4479 return FALSE;
4480 }
4481 case ltTEXTWIDTH:
4482 {
4483 if (start)
4484 {
4485 char *val = GetArgData();
4486 int twips = (int)(20*ParseUnitArgument(val));
4487 CurrentTextWidth = twips;
4488
4489 // Need to set an implicit right margin
4490 CurrentRightMarginOdd = PageWidth - CurrentTextWidth - CurrentLeftMarginOdd;
4491 CurrentRightMarginEven = PageWidth - CurrentTextWidth - CurrentLeftMarginEven;
4492 CurrentMarginParX = CurrentLeftMarginOdd + CurrentTextWidth + CurrentMarginParSep;
4493 sprintf(buf, "\\margr%d\n", CurrentRightMarginOdd);
4494 TexOutput(buf);
4495 }
4496 return FALSE;
4497 }
4498 case ltMARGINPAR:
4499 case ltMARGINPARODD:
4500 {
4501 if (start)
4502 {
4503 if (winHelp)
4504 {
4505 TexOutput("\\box\n");
4506 PushEnvironmentStyle("\\box");
4507 }
4508 else
4509 {
4510 sprintf(buf, "\\phpg\\posx%d\\absw%d\n", CurrentMarginParX, CurrentMarginParWidth);
4511 TexOutput(buf);
4512 }
4513 return TRUE;
4514 }
4515 else
4516 {
4517 if (winHelp)
4518 {
4519 TexOutput("\\par\\pard\n");
4520 PopEnvironmentStyle();
4521 WriteEnvironmentStyles();
4522 }
4523 else
4524 TexOutput("\\par\\pard\n");
4525 issuedNewParagraph = 1;
4526 }
4527 return FALSE;
4528 }
4529 case ltMARGINPAREVEN:
4530 {
4531 if (start)
4532 {
4533 if (winHelp)
4534 {
4535 TexOutput("\\box\n");
4536 PushEnvironmentStyle("\\box");
4537 }
4538 else
4539 {
4540 if (mirrorMargins)
4541 {
4542 // Have to calculate what the margins are changed to in WfW margin
4543 // mirror mode, on an even (left-hand) page.
4544 int x = PageWidth - CurrentRightMarginOdd - CurrentMarginParWidth - CurrentMarginParSep
4545 - CurrentTextWidth + GutterWidth;
4546 sprintf(buf, "\\phpg\\posx%d\\absw%d\n", x, CurrentMarginParWidth);
4547 TexOutput(buf);
4548 }
4549 else
4550 {
4551 sprintf(buf, "\\phpg\\posx%d\\absw%d\n", CurrentMarginParX, CurrentMarginParWidth);
4552 TexOutput(buf);
4553 }
4554 }
4555 return TRUE;
4556 }
4557 else
4558 {
4559 if (winHelp)
4560 {
4561 TexOutput("\\par\\pard\n");
4562 PopEnvironmentStyle();
4563 WriteEnvironmentStyles();
4564 }
4565 else
4566 issuedNewParagraph = 1;
4567 TexOutput("\\par\\pard\n");
4568 }
4569 return FALSE;
4570 }
4571 case ltTWOCOLWIDTHA:
4572 {
4573 if (start)
4574 {
4575 char *val = GetArgData();
4576 int twips = (int)(20*ParseUnitArgument(val));
4577 TwoColWidthA = twips;
4578 }
4579 return FALSE;
4580 break;
4581 }
4582 case ltTWOCOLWIDTHB:
4583 {
4584 if (start)
4585 {
4586 char *val = GetArgData();
4587 int twips = (int)(20*ParseUnitArgument(val));
4588 TwoColWidthB = twips;
4589 }
4590 return FALSE;
4591 break;
4592 }
4593 case ltROW:
4594 case ltRULEDROW:
4595 {
4596 if (start)
4597 {
4598 int currentWidth = 0;
4599
4600 if (!compatibilityMode || (currentRowNumber > 0))
4601 {
4602 TexOutput("\\pard\\intbl");
4603
4604 if (macroId == ltRULEDROW)
4605 ruleBottom = 1;
4606 for (int i = 0; i < noColumns; i++)
4607 {
4608 currentWidth += TableData[i].width;
4609 if (ruleTop == 1)
4610 {
4611 TexOutput("\\clbrdrt\\brdrs\\brdrw15");
4612 }
4613 else if (ruleTop > 1)
4614 {
4615 TexOutput("\\clbrdrt\\brdrdb\\brdrw15");
4616 }
4617 if (ruleBottom == 1)
4618 {
4619 TexOutput("\\clbrdrb\\brdrs\\brdrw15");
4620 }
4621 else if (ruleBottom > 1)
4622 {
4623 TexOutput("\\clbrdrb\\brdrdb\\brdrw15");
4624 }
4625
4626 if (TableData[i].rightBorder)
4627 TexOutput("\\clbrdrr\\brdrs\\brdrw15");
4628
4629 if (TableData[i].leftBorder)
4630 TexOutput("\\clbrdrl\\brdrs\\brdrw15");
4631
4632 sprintf(buf, "\\cellx%d", currentWidth);
4633 TexOutput(buf);
4634 }
4635 TexOutput("\\pard\\intbl\n");
4636 }
4637 ruleTop = 0;
4638 ruleBottom = 0;
4639 currentRowNumber ++;
4640 return TRUE;
4641 }
4642 else
4643 {
4644 // TexOutput("\\cell\\row\\trowd\\trgaph108\\trleft-108\n");
4645 TexOutput("\\cell\\row\\trowd\\trgaph108\n");
4646 }
4647 break;
4648 }
4649 case ltMULTICOLUMN:
4650 {
4651 static int noMultiColumns = 0;
4652 if (start)
4653 {
4654 switch (arg_no)
4655 {
4656 case 1:
4657 {
4658 noMultiColumns = atoi(GetArgData());
4659 return FALSE;
4660 break;
4661 }
4662 case 2:
4663 {
4664 return FALSE;
4665 }
4666 case 3:
4667 {
4668 return TRUE;
4669 }
4670 }
4671 }
4672 else
4673 {
4674 if (arg_no == 3)
4675 {
4676 for (int i = 1; i < noMultiColumns; i ++)
4677 TexOutput("\\cell");
4678 }
4679 }
4680 break;
4681 }
4682 case ltINDENTED:
4683 {
4684 if (start && (arg_no == 1))
4685 {
4686 // indentLevel ++;
4687 // TexOutput("\\fi0\n");
4688 int oldIndent = 0;
4689 wxNode *node = itemizeStack.First();
4690 if (node)
4691 oldIndent = ((ItemizeStruc *)node->Data())->indentation;
4692
4693 int indentValue = 20*ParseUnitArgument(GetArgData());
4694 int indentSize = indentValue + oldIndent;
4695
4696 ItemizeStruc *struc = new ItemizeStruc(LATEX_INDENT, indentSize);
4697 itemizeStack.Insert(struc);
4698
4699 sprintf(buf, "\\tx%d\\li%d ", indentSize, indentSize);
4700 PushEnvironmentStyle(buf);
4701 TexOutput(buf);
4702 return FALSE;
4703 }
4704 if (!start && (arg_no == 2))
4705 {
4706 PopEnvironmentStyle();
4707 if (itemizeStack.First())
4708 {
4709 ItemizeStruc *struc = (ItemizeStruc *)itemizeStack.First()->Data();
4710 delete struc;
4711 delete itemizeStack.First();
4712 }
4713 if (itemizeStack.Number() == 0)
4714 {
4715 TexOutput("\\par\\pard\n");
4716 issuedNewParagraph = 1;
4717 WriteEnvironmentStyles();
4718 }
4719 }
4720 return TRUE;
4721 break;
4722 }
4723 /*
4724 case ltSIZEDBOX:
4725 case ltSIZEDBOXD:
4726 {
4727 if (start && (arg_no == 1))
4728 {
4729 int oldIndent = 0;
4730 wxNode *node = itemizeStack.First();
4731 if (node)
4732 oldIndent = ((ItemizeStruc *)node->Data())->indentation;
4733
4734 int boxWidth = 20*ParseUnitArgument(GetArgData());
4735
4736 int indentValue = (int)((CurrentTextWidth - oldIndent - boxWidth)/2.0);
4737 int indentSize = indentValue + oldIndent;
4738 int indentSizeRight = indentSize + boxWidth;
4739
4740 ItemizeStruc *struc = new ItemizeStruc(LATEX_INDENT, indentSize);
4741 itemizeStack.Insert(struc);
4742
4743 sprintf(buf, "\\tx%d\\li%d\\lr%d\\box%s ", indentSize, indentSize, indentSizeRight,
4744 ((macroId == ltCENTEREDBOX) ? "\\brdrs" : "\\brdrdb"));
4745 PushEnvironmentStyle(buf);
4746 TexOutput(buf);
4747 return FALSE;
4748 }
4749 if (!start && (arg_no == 2))
4750 {
4751 PopEnvironmentStyle();
4752 if (itemizeStack.First())
4753 {
4754 ItemizeStruc *struc = (ItemizeStruc *)itemizeStack.First()->Data();
4755 delete struc;
4756 delete itemizeStack.First();
4757 }
4758 if (itemizeStack.Number() == 0)
4759 {
4760 TexOutput("\\par\\pard\n");
4761 issuedNewParagraph = 1;
4762 WriteEnvironmentStyles();
4763 }
4764 }
4765 return TRUE;
4766 break;
4767 }
4768 */
4769 case ltDOCUMENTSTYLE:
4770 {
4771 DefaultOnArgument(macroId, arg_no, start);
4772 if (!start && !IsArgOptional())
4773 {
4774 if (MinorDocumentStyleString)
4775 {
4776 if (StringMatch("twoside", MinorDocumentStyleString))
4777 // Mirror margins, switch on odd/even headers & footers, and break sections at odd pages
4778 TexOutput("\\margmirror\\facingp\\sbkodd");
4779 if (StringMatch("twocolumn", MinorDocumentStyleString))
4780 TexOutput("\\cols2");
4781 }
4782 TexOutput("\n");
4783 }
4784 return FALSE;
4785 }
4786 case ltSETHOTSPOTCOLOUR:
4787 case ltSETHOTSPOTCOLOR:
4788 {
4789 if (!start)
4790 {
4791 char *text = GetArgData();
4792 if (strcmp(text, "yes") == 0 || strcmp(text, "on") == 0 || strcmp(text, "ok") == 0)
4793 hotSpotColour = TRUE;
4794 else
4795 hotSpotColour = FALSE;
4796 }
4797 return FALSE;
4798 }
4799 case ltSETTRANSPARENCY:
4800 {
4801 if (!start)
4802 {
4803 char *text = GetArgData();
4804 if (strcmp(text, "yes") == 0 || strcmp(text, "on") == 0 || strcmp(text, "ok") == 0)
4805 bitmapTransparency = TRUE;
4806 else
4807 bitmapTransparency = FALSE;
4808 }
4809 return FALSE;
4810 }
4811 case ltSETHOTSPOTUNDERLINE:
4812 {
4813 if (!start)
4814 {
4815 char *text = GetArgData();
4816 if (strcmp(text, "yes") == 0 || strcmp(text, "on") == 0 || strcmp(text, "ok") == 0)
4817 hotSpotUnderline = TRUE;
4818 else
4819 hotSpotUnderline = FALSE;
4820 }
4821 return FALSE;
4822 }
4823 case ltBIBITEM:
4824 {
4825 if (arg_no == 1 && start)
4826 {
4827 char *citeKey = GetArgData();
4828 TexRef *ref = (TexRef *)TexReferences.Get(citeKey);
4829 if (ref)
4830 {
4831 if (ref->sectionNumber) delete[] ref->sectionNumber;
4832 sprintf(buf, "[%d]", citeCount);
4833 ref->sectionNumber = copystring(buf);
4834 }
4835
4836 TexOutput("\\li260\\fi-260 "); // Indent from 2nd line
4837 sprintf(buf, "{\\b [%d]} ", citeCount);
4838 TexOutput(buf);
4839 citeCount ++;
4840 return FALSE;
4841 }
4842 if (arg_no == 2 && !start)
4843 TexOutput("\\par\\pard\\par\n\n");
4844 return TRUE;
4845 break;
4846 }
4847 case ltTHEBIBLIOGRAPHY:
4848 {
4849 if (start && (arg_no == 1))
4850 {
4851 citeCount = 1;
4852 if (winHelp)
4853 SetCurrentOutputs(Contents, Chapters);
4854
4855 if (!winHelp)
4856 {
4857 fprintf(Chapters, "\\sect\\pgncont\\titlepg\n");
4858
4859 // If a non-custom page style, we generate the header now.
4860 if (PageStyle && (strcmp(PageStyle, "plain") == 0 ||
4861 strcmp(PageStyle, "empty") == 0 ||
4862 strcmp(PageStyle, "headings") == 0))
4863 {
4864 OutputRTFHeaderCommands();
4865 OutputRTFFooterCommands();
4866 }
4867
4868 // Need to reset the current numbering style, or RTF forgets it.
4869 OutputNumberStyle(currentNumberStyle);
4870 SetCurrentOutput(Contents);
4871 }
4872 else
4873 fprintf(Chapters, "\\page\n");
4874
4875 if (winHelp)
4876 fprintf(Contents, "\n{\\uldb %s}", ReferencesNameString);
4877 else
4878 fprintf(Contents, "\\par\n\\pard{\\b %s}", ReferencesNameString);
4879
4880 startedSections = TRUE;
4881
4882 if (winHelp)
4883 fprintf(Chapters, "\n${\\footnote %s}", ReferencesNameString);
4884
4885 char *topicName = "bibliography";
4886
4887 if (winHelp)
4888 fprintf(Contents, "{\\v %s}\\par\\pard\n", topicName);
4889 else
4890 fprintf(Contents, "\\par\\par\\pard\n");
4891
4892 if (winHelp)
4893 {
4894 fprintf(Chapters, "\n#{\\footnote %s}\n", topicName);
4895 fprintf(Chapters, "+{\\footnote %s}\n", GetBrowseString());
4896 fprintf(Chapters, "K{\\footnote {K} %s}\n", ReferencesNameString);
4897 GenerateKeywordsForTopic(topicName);
4898 if (useUpButton)
4899 {
4900 fprintf(Chapters, "!{\\footnote EnableButton(\"Up\");ChangeButtonBinding(\"Up\", \"JumpId(`%s.hlp', `%s')\")}\n",
4901 FileNameFromPath(FileRoot), "Contents");
4902 }
4903 }
4904
4905 SetCurrentOutput(Chapters);
4906 char *styleCommand = "";
4907 if (!winHelp && useHeadingStyles)
4908 styleCommand = "\\s1";
4909 fprintf(Chapters, "\\pard{%s", (winHelp ? "\\keepn\\sa140\\sb140" : styleCommand));
4910 WriteHeadingStyle(Chapters, 1); fprintf(Chapters, " References\\par\\pard}\n");
4911
4912 return FALSE;
4913 }
4914 return TRUE;
4915 break;
4916 }
4917 case ltINDEX:
4918 {
4919 /*
4920 * In Windows help, all keywords should be at the start of the
4921 * topic, but Latex \index commands can be anywhere in the text.
4922 * So we're going to have to build up lists of keywords for a topic,
4923 * and insert them on the second pass.
4924 *
4925 * In linear RTF, we can embed the index entry now.
4926 *
4927 */
4928 if (start)
4929 {
4930 // char *entry = GetArgData();
4931 char buf[300];
4932 OutputChunkToString(GetArgChunk(), buf);
4933 if (winHelp)
4934 {
4935 if (CurrentTopic)
4936 {
4937 AddKeyWordForTopic(CurrentTopic, buf);
4938 }
4939 }
4940 else GenerateIndexEntry(buf);
4941 }
4942 return FALSE;
4943 break;
4944 }
4945 case ltFCOL:
4946 case ltBCOL:
4947 {
4948 if (start)
4949 {
4950 switch (arg_no)
4951 {
4952 case 1:
4953 {
4954 char *name = GetArgData();
4955 int pos = FindColourPosition(name);
4956 if (pos > -1)
4957 {
4958 sprintf(buf, "{%s%d ", ((macroId == ltFCOL) ? "\\cf" : "\\cb"), pos);
4959 TexOutput(buf);
4960 }
4961 else
4962 {
4963 sprintf(buf, "Could not find colour name %s", name);
4964 OnError(buf);
4965 }
4966 break;
4967 }
4968 case 2:
4969 {
4970 return TRUE;
4971 break;
4972 }
4973 default:
4974 break;
4975 }
4976 }
4977 else
4978 {
4979 if (arg_no == 2) TexOutput("}");
4980 }
4981 return FALSE;
4982 break;
4983 }
4984 case ltLABEL:
4985 {
4986 if (start && !winHelp && useWord)
4987 {
4988 char *s = GetArgData();
4989 // Only insert a bookmark here if it's not just been inserted
4990 // in a section heading.
4991 if ( !CurrentTopic || !(strcmp(CurrentTopic, s) == 0) )
4992 /*
4993 if ( (!CurrentChapterName || !(CurrentChapterName && (strcmp(CurrentChapterName, s) == 0))) &&
4994 (!CurrentSectionName || !(CurrentSectionName && (strcmp(CurrentSectionName, s) == 0))) &&
4995 (!CurrentSubsectionName || !(CurrentSubsectionName && (strcmp(CurrentSubsectionName, s) == 0)))
4996 )
4997 */
4998 {
4999 fprintf(Chapters, "{\\bkmkstart %s}{\\bkmkend %s}", s,s);
5000 }
5001 }
5002 return FALSE;
5003 break;
5004 }
5005 case ltPAGEREF:
5006 {
5007 if (start && useWord && !winHelp)
5008 {
5009 char *s = GetArgData();
5010 fprintf(Chapters, "{\\field{\\*\\fldinst PAGEREF %s \\\\* MERGEFORMAT }{\\fldrslt ??}}",
5011 s);
5012 }
5013 return FALSE;
5014 break;
5015 }
5016 case ltPOPREFONLY:
5017 {
5018 if (start)
5019 inPopRefSection = TRUE;
5020 else
5021 inPopRefSection = FALSE;
5022 break;
5023 }
5024 case ltINSERTATLEVEL:
5025 {
5026 // This macro allows you to insert text at a different level
5027 // from the current level, e.g. into the Sections from within a subsubsection.
5028 if (!winHelp & useWord)
5029 return FALSE;
5030 static int currentLevelNo = 1;
5031 static FILE* oldLevelFile = Chapters;
5032 if (start)
5033 {
5034 switch (arg_no)
5035 {
5036 case 1:
5037 {
5038 oldLevelFile = CurrentOutput1;
5039
5040 char *str = GetArgData();
5041 currentLevelNo = atoi(str);
5042 FILE* outputFile;
5043 // TODO: cope with article style (no chapters)
5044 switch (currentLevelNo)
5045 {
5046 case 1:
5047 {
5048 outputFile = Chapters;
5049 break;
5050 }
5051 case 2:
5052 {
5053 outputFile = Sections;
5054 break;
5055 }
5056 case 3:
5057 {
5058 outputFile = Subsections;
5059 break;
5060 }
5061 case 4:
5062 {
5063 outputFile = Subsubsections;
5064 break;
5065 }
5066 default:
5067 {
5068 outputFile = NULL;
5069 break;
5070 }
5071 }
5072 if (outputFile)
5073 CurrentOutput1 = outputFile;
5074 return FALSE;
5075 break;
5076 }
5077 case 2:
5078 {
5079 return TRUE;
5080 break;
5081 }
5082 default:
5083 break;
5084 }
5085 return TRUE;
5086 }
5087 else
5088 {
5089 if (arg_no == 2)
5090 {
5091 CurrentOutput1 = oldLevelFile;
5092 }
5093 return TRUE;
5094 }
5095 break;
5096 }
5097 default:
5098 {
5099 return DefaultOnArgument(macroId, arg_no, start);
5100 break;
5101 }
5102 }
5103 return TRUE;
5104 }
5105
5106 bool RTFGo(void)
5107 {
5108 if (stopRunning)
5109 return FALSE;
5110
5111 // Reset variables
5112 indentLevel = 0;
5113 forbidParindent = 0;
5114 contentsLineSection = NULL;
5115 contentsLineValue = NULL;
5116 descriptionItemArg = NULL;
5117 inTabular = FALSE;
5118 inTable = FALSE;
5119 inFigure = FALSE;
5120 startRows = FALSE;
5121 tableVerticalLineLeft = FALSE;
5122 tableVerticalLineRight = FALSE;
5123 noColumns = 0;
5124 startedSections = FALSE;
5125 inVerbatim = FALSE;
5126 browseId = 0;
5127
5128 if (InputFile && OutputFile)
5129 {
5130 // Do some RTF-specific transformations on all the strings,
5131 // recursively
5132 Text2RTF(GetTopLevelChunk());
5133
5134 Contents = fopen(TmpContentsName, "w");
5135 Chapters = fopen("chapters.rtf", "w");
5136 if (winHelp)
5137 {
5138 Sections = fopen("sections.rtf", "w");
5139 Subsections = fopen("subsections.rtf", "w");
5140 Subsubsections = fopen("subsubsections.rtf", "w");
5141 Popups = fopen("popups.rtf", "w");
5142 if (winHelpContents)
5143 {
5144 WinHelpContentsFile = fopen(WinHelpContentsFileName, "w");
5145 if (WinHelpContentsFile)
5146 fprintf(WinHelpContentsFile, ":Base %s.hlp\n", wxFileNameFromPath(FileRoot));
5147 }
5148
5149 if (!Sections || !Subsections || !Subsubsections || !Popups || (winHelpContents && !WinHelpContentsFile))
5150 {
5151 OnError("Ouch! Could not open temporary file(s) for writing.");
5152 return FALSE;
5153 }
5154 }
5155 if (!Contents || !Chapters)
5156 {
5157 OnError("Ouch! Could not open temporary file(s) for writing.");
5158 return FALSE;
5159 }
5160
5161 if (winHelp)
5162 {
5163 fprintf(Chapters, "\n#{\\footnote Contents}\n");
5164 fprintf(Chapters, "${\\footnote Contents}\n");
5165 fprintf(Chapters, "+{\\footnote %s}\n", GetBrowseString());
5166 fprintf(Chapters, "K{\\footnote {K} %s}\n", ContentsNameString);
5167 fprintf(Chapters, "!{\\footnote DisableButton(\"Up\")}\n");
5168 }
5169 if (!winHelp)
5170 {
5171 fprintf(Chapters, "\\titlepg\n");
5172 fprintf(Contents, "\\par\\pard\\pgnrestart\\sect\\titlepg");
5173 }
5174
5175 // In WinHelp, Contents title takes font of title.
5176 // In linear RTF, same as chapter headings.
5177 fprintf(Contents, "{\\b\\fs%d %s}\\par\\par\\pard\n\n",
5178 (winHelp ? titleFont : chapterFont)*2, ContentsNameString);
5179
5180 // By default, Swiss, 10 point.
5181 fprintf(Chapters, "\\f2\\fs20\n");
5182
5183 SetCurrentOutput(Chapters);
5184
5185 if (stopRunning)
5186 return FALSE;
5187
5188 OnInform("Converting...");
5189
5190 TraverseDocument();
5191
5192 FILE *Header = fopen("header.rtf", "w");
5193 if (!Header)
5194 {
5195 OnError("Ouch! Could not open temporary file header.rtf for writing.");
5196 return FALSE;
5197 }
5198 WriteRTFHeader(Header);
5199 fclose(Header); Header = NULL;
5200
5201 Tex2RTFYield(TRUE);
5202 if (winHelp)
5203 {
5204 // fprintf(Contents, "\\page\n");
5205 fprintf(Chapters, "\\page\n");
5206 fprintf(Sections, "\\page\n");
5207 fprintf(Subsections, "\\page\n");
5208 fprintf(Subsubsections, "\\page\n\n");
5209 fprintf(Popups, "\\page\n}\n");
5210 }
5211
5212 // TexOutput("\n\\info{\\doccomm Document created by Julian Smart's Tex2RTF.}\n");
5213 if (!winHelp)
5214 TexOutput("}\n");
5215 fclose(Contents); Contents = NULL;
5216 fclose(Chapters); Chapters = NULL;
5217 if (winHelp)
5218 {
5219 fclose(Sections); Sections = NULL;
5220 fclose(Subsections); Subsections = NULL;
5221 fclose(Subsubsections); Subsubsections = NULL;
5222 fclose(Popups); Popups = NULL;
5223 if (winHelpContents)
5224 {
5225 fclose(WinHelpContentsFile); WinHelpContentsFile = NULL;
5226 }
5227 }
5228
5229 if (winHelp)
5230 {
5231 wxConcatFiles("header.rtf", "chapters.rtf", "tmp1.rtf");
5232 Tex2RTFYield(TRUE);
5233 wxConcatFiles("tmp1.rtf", "sections.rtf", "tmp2.rtf");
5234 Tex2RTFYield(TRUE);
5235 wxConcatFiles("tmp2.rtf", "subsections.rtf", "tmp3.rtf");
5236 Tex2RTFYield(TRUE);
5237 wxConcatFiles("tmp3.rtf", "subsubsections.rtf", "tmp4.rtf");
5238 Tex2RTFYield(TRUE);
5239 wxConcatFiles("tmp4.rtf", "popups.rtf", OutputFile);
5240 Tex2RTFYield(TRUE);
5241
5242 wxRemoveFile("tmp1.rtf");
5243 wxRemoveFile("tmp2.rtf");
5244 wxRemoveFile("tmp3.rtf");
5245 wxRemoveFile("tmp4.rtf");
5246 }
5247 else
5248 {
5249 wxConcatFiles("header.rtf", "chapters.rtf", "tmp1.rtf");
5250 Tex2RTFYield(TRUE);
5251 if (FileExists(OutputFile))
5252 wxRemoveFile(OutputFile);
5253
5254 char *cwdStr;
5255 cwdStr = wxGetWorkingDirectory();
5256
5257 wxString outputDirStr;
5258 outputDirStr = wxPathOnly(OutputFile);
5259
5260 // Determine if the temp file and the output file are in the same directory,
5261 // and if they are, then just rename the temp file rather than copying
5262 // it, as this is much faster when working with large (multi-megabyte files)
5263 if ((wxStrcmp(outputDirStr.c_str(),"") == 0) || // no path specified on output file
5264 (wxStrcmp(cwdStr,outputDirStr.c_str()) == 0)) // paths do not match
5265 {
5266 wxRenameFile("tmp1.rtf", OutputFile);
5267 }
5268 else
5269 {
5270 wxCopyFile("tmp1.rtf", OutputFile);
5271 }
5272 delete [] cwdStr;
5273 Tex2RTFYield(TRUE);
5274 wxRemoveFile("tmp1.rtf");
5275 }
5276
5277 if (FileExists(ContentsName)) wxRemoveFile(ContentsName);
5278
5279 if (!wxRenameFile(TmpContentsName, ContentsName))
5280 {
5281 wxCopyFile(TmpContentsName, ContentsName);
5282 wxRemoveFile(TmpContentsName);
5283 }
5284
5285 wxRemoveFile("chapters.rtf");
5286 wxRemoveFile("header.rtf");
5287
5288 if (winHelp)
5289 {
5290 wxRemoveFile("sections.rtf");
5291 wxRemoveFile("subsections.rtf");
5292 wxRemoveFile("subsubsections.rtf");
5293 wxRemoveFile("popups.rtf");
5294 }
5295 if (winHelp && generateHPJ)
5296 WriteHPJ(OutputFile);
5297 return TRUE;
5298 }
5299 return FALSE;
5300 }