home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / utils / tex2rtf / src / tex2rtf.cpp < prev    next >
C/C++ Source or Header  |  2002-08-07  |  32KB  |  1,335 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        tex2rtf.cpp
  3. // Purpose:     Converts Latex to linear/WinHelp RTF, HTML, wxHelp.
  4. // Author:      Julian Smart
  5. // Modified by:
  6. // Created:     7.9.93
  7. // RCS-ID:      $Id: tex2rtf.cpp,v 1.26 2002/08/07 09:56:22 JS Exp $
  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. #ifndef NO_GUI
  28. #include "wx/help.h"
  29. #include "wx/timer.h"
  30. #endif
  31.  
  32. #if defined(NO_GUI) || defined(__UNIX__)
  33. #if wxUSE_IOSTREAMH
  34. #include <iostream.h>
  35. #include <fstream.h>
  36. #else
  37. #include <iostream>
  38. #include <fstream>
  39. #endif
  40. #endif
  41.  
  42. #include <ctype.h>
  43. #include <stdlib.h>
  44. #include "tex2any.h"
  45. #include "tex2rtf.h"
  46. #include "rtfutils.h"
  47. #include "symbols.h"
  48.  
  49. #if (defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__)) && !defined(NO_GUI)
  50. #include "tex2rtf.xpm"
  51. #endif
  52.  
  53. const float versionNo = TEX2RTF_VERSION_NUMBER;
  54.  
  55. TexChunk *currentMember = NULL;
  56. bool startedSections = FALSE;
  57. char *contentsString = NULL;
  58. bool suppressNameDecoration = FALSE;
  59. bool OkToClose = TRUE;
  60. int passNumber = 1;
  61. int errorCount = 0;
  62.  
  63. #ifndef NO_GUI
  64.  
  65. extern char *BigBuffer;
  66. extern char *TexFileRoot;
  67. extern char *TexBibName;         // Bibliography output file name
  68. extern char *TexTmpBibName;      // Temporary bibliography output file name
  69. extern wxList ColourTable;
  70. extern TexChunk *TopLevel;
  71. extern char *PageStyle;
  72. extern char *BibliographyStyleString;
  73. extern char *DocumentStyleString;
  74. extern char *bitmapMethod;
  75. extern char *backgroundColourString;
  76. extern char *ContentsNameString;
  77. extern char *AbstractNameString;
  78. extern char *GlossaryNameString;
  79. extern char *ReferencesNameString;
  80. extern char *FiguresNameString;
  81. extern char *TablesNameString;
  82. extern char *FigureNameString;
  83. extern char *TableNameString;
  84. extern char *IndexNameString;
  85. extern char *ChapterNameString;
  86. extern char *SectionNameString;
  87. extern char *SubsectionNameString;
  88. extern char *SubsubsectionNameString;
  89. extern char *UpNameString;
  90.  
  91.  
  92.  
  93. #if wxUSE_HELP
  94. wxHelpController *HelpInstance = NULL;
  95. #endif // wxUSE_HELP
  96.  
  97. #ifdef __WXMSW__
  98. static char *ipc_buffer = NULL;
  99. static char Tex2RTFLastStatus[100];
  100. Tex2RTFServer *TheTex2RTFServer = NULL;
  101. #endif
  102. #endif
  103.  
  104. char *bulletFile = NULL;
  105.  
  106. FILE *Contents = NULL;   // Contents page
  107. FILE *Chapters = NULL;   // Chapters (WinHelp RTF) or rest of file (linear RTF)
  108. FILE *Sections = NULL;
  109. FILE *Subsections = NULL;
  110. FILE *Subsubsections = NULL;
  111. FILE *Popups = NULL;
  112. FILE *WinHelpContentsFile = NULL;
  113.  
  114. char *InputFile = NULL;
  115. char *OutputFile = NULL;
  116. char *MacroFile = copystring("tex2rtf.ini");
  117.  
  118. char *FileRoot = NULL;
  119. char *ContentsName = NULL;    // Contents page from last time around
  120. char *TmpContentsName = NULL; // Current contents page
  121. char *TmpFrameContentsName = NULL; // Current frame contents page
  122. char *WinHelpContentsFileName = NULL; // WinHelp .cnt file
  123. char *RefFileName = NULL;         // Reference file name
  124.  
  125. char *RTFCharset = copystring("ansi");
  126.  
  127. #ifdef __WXMSW__
  128. int BufSize = 100;             // Size of buffer in K
  129. #else
  130. int BufSize = 500;
  131. #endif
  132.  
  133. bool Go(void);
  134. void ShowOptions(void);
  135.  
  136. char wxTex2RTFBuffer[1500];
  137.  
  138. #ifdef NO_GUI
  139.  
  140. int main(int argc, char **argv)
  141. #else
  142. wxMenuBar *menuBar = NULL;
  143. MyFrame *frame = NULL;
  144.  
  145. // DECLARE_APP(MyApp)
  146. IMPLEMENT_APP(MyApp)
  147.  
  148. // `Main program' equivalent, creating windows and returning main app frame
  149. bool MyApp::OnInit()
  150. #endif
  151. {
  152.   // Use default list of macros defined in tex2any.cc
  153.   DefineDefaultMacros();
  154.   AddMacroDef(ltHARDY, "hardy", 0);
  155.  
  156.   FileRoot = new char[300];
  157.   ContentsName = new char[300];
  158.   TmpContentsName = new char[300];
  159.   TmpFrameContentsName = new char[300];
  160.   WinHelpContentsFileName = new char[300];
  161.   RefFileName = new char[300];
  162.  
  163.   ColourTable.DeleteContents(TRUE);
  164.  
  165.   int n = 1;
  166.  
  167.   // Read input/output files
  168.   if (argc > 1)
  169.   {
  170.     if (argv[1][0] != '-')
  171.     {
  172.       InputFile = argv[1];
  173.       n ++;
  174.  
  175.       if (argc > 2)
  176.       {
  177.         if (argv[2][0] != '-')
  178.         {
  179.           OutputFile = argv[2];
  180.           n ++;
  181.         }
  182.       }
  183.     }
  184.   }
  185.  
  186. #ifdef NO_GUI
  187.   if (!InputFile || !OutputFile)
  188.   {
  189.     wxSTD cout << "Tex2RTF: input or output file is missing.\n";
  190.     ShowOptions();
  191.     exit(1);
  192.   }
  193.  
  194. #endif
  195.   if (InputFile)
  196.   {
  197.     TexPathList.EnsureFileAccessible(InputFile);
  198.   }
  199.   if (!InputFile || !OutputFile)
  200.     isInteractive = TRUE;
  201.  
  202.   int i;
  203.   for (i = n; i < argc;)
  204.   {
  205.     if (strcmp(argv[i], "-winhelp") == 0)
  206.     {
  207.       i ++;
  208.       convertMode = TEX_RTF;
  209.       winHelp = TRUE;
  210.     }
  211. #ifndef NO_GUI
  212.     else if (strcmp(argv[i], "-interactive") == 0)
  213.     {
  214.       i ++;
  215.       isInteractive = TRUE;
  216.     }
  217. #endif
  218.     else if (strcmp(argv[i], "-sync") == 0)  // Don't yield
  219.     {
  220.       i ++;
  221.       isSync = TRUE;
  222.     }
  223.     else if (strcmp(argv[i], "-rtf") == 0)
  224.     {
  225.       i ++;
  226.       convertMode = TEX_RTF;
  227.     }
  228.     else if (strcmp(argv[i], "-html") == 0)
  229.     {
  230.       i ++;
  231.       convertMode = TEX_HTML;
  232.     }
  233.     else if (strcmp(argv[i], "-xlp") == 0)
  234.     {
  235.       i ++;
  236.       convertMode = TEX_XLP;
  237.     }
  238.     else if (strcmp(argv[i], "-twice") == 0)
  239.     {
  240.       i ++;
  241.       runTwice = TRUE;
  242.     }
  243.     else if (strcmp(argv[i], "-macros") == 0)
  244.     {
  245.       i ++;
  246.       if (i < argc)
  247.       {
  248.         MacroFile = copystring(argv[i]);
  249.         i ++;
  250.       }
  251.     }
  252.     else if (strcmp(argv[i], "-bufsize") == 0)
  253.     {
  254.       i ++;
  255.       if (i < argc)
  256.       {
  257.         BufSize = atoi(argv[i]);
  258.         i ++;
  259.       }
  260.     }
  261.     else if (strcmp(argv[i], "-charset") == 0)
  262.     {
  263.       i ++;
  264.       if (i < argc)
  265.       {
  266.         char *s = argv[i];
  267.         i ++;
  268.         if (strcmp(s, "ansi") == 0 || strcmp(s, "pc") == 0 || strcmp(s, "mac") == 0 ||
  269.             strcmp(s, "pca") == 0)
  270.           RTFCharset = copystring(s);
  271.         else
  272.         {
  273.           OnError("Incorrect argument for -charset");
  274.           return FALSE;
  275.         }
  276.       }
  277.     }
  278.     else if (strcmp(argv[i], "-checkcurleybraces") == 0)
  279.     {
  280.       i ++;
  281.       checkCurleyBraces = TRUE;
  282.     }
  283.     else if (strcmp(argv[i], "-checksyntax") == 0)
  284.     {
  285.       i ++;
  286.       checkSyntax = TRUE;
  287.     }
  288.     else
  289.     {
  290.       wxString buf;
  291.       buf.Printf("Invalid switch %s.\n", argv[i]);
  292.       OnError((char *)buf.c_str());
  293.       i++;
  294. #ifdef NO_GUI
  295.       ShowOptions();
  296.       exit(1);
  297. #endif
  298.       return FALSE;
  299.     }
  300.   }
  301.  
  302. #if defined(__WXMSW__) && !defined(NO_GUI)
  303.   wxDDEInitialize();
  304.   Tex2RTFLastStatus[0] = 0; // DDE connection return value
  305.   TheTex2RTFServer = new Tex2RTFServer;
  306.   TheTex2RTFServer->Create("TEX2RTF");
  307. #endif
  308.  
  309. #if defined(__WXMSW__) && defined(__WIN16__)
  310.   // Limit to max Windows array size
  311.   if (BufSize > 64) BufSize = 64;
  312. #endif
  313.  
  314.   TexInitialize(BufSize);
  315.   ResetContentsLevels(0);
  316.  
  317. #ifndef NO_GUI
  318.  
  319.   if (isInteractive)
  320.   {
  321.     char buf[100];
  322.  
  323.     // Create the main frame window
  324.     frame = new MyFrame(NULL, -1, "Tex2RTF", wxPoint(-1, -1), wxSize(400, 300));
  325.     frame->CreateStatusBar(2);
  326.  
  327.     // Give it an icon
  328.     // TODO: uncomment this when we have tex2rtf.xpm
  329.     frame->SetIcon(wxICON(tex2rtf));
  330.  
  331.     if (InputFile)
  332.     {
  333.       sprintf(buf, "Tex2RTF [%s]", FileNameFromPath(InputFile));
  334.       frame->SetTitle(buf);
  335.     }
  336.  
  337.     // Make a menubar
  338.     wxMenu *file_menu = new wxMenu;
  339.     file_menu->Append(TEX_GO, "&Go",                        "Run converter");
  340.     file_menu->Append(TEX_SET_INPUT, "Set &Input File",     "Set the LaTeX input file");
  341.     file_menu->Append(TEX_SET_OUTPUT, "Set &Output File",   "Set the output file");
  342.     file_menu->AppendSeparator();
  343.     file_menu->Append(TEX_VIEW_LATEX, "View &LaTeX File",   "View the LaTeX input file");
  344.     file_menu->Append(TEX_VIEW_OUTPUT, "View Output &File", "View output file");
  345.     file_menu->Append(TEX_SAVE_FILE, "&Save log file", "Save displayed text into file");
  346.     file_menu->AppendSeparator();
  347.     file_menu->Append(TEX_QUIT, "E&xit",                    "Exit Tex2RTF");
  348.  
  349.     wxMenu *macro_menu = new wxMenu;
  350.  
  351.     macro_menu->Append(TEX_LOAD_CUSTOM_MACROS, "&Load Custom Macros", "Load custom LaTeX macro file");
  352.     macro_menu->Append(TEX_VIEW_CUSTOM_MACROS, "View &Custom Macros", "View custom LaTeX macros");
  353.  
  354.     wxMenu *mode_menu = new wxMenu;
  355.  
  356.     mode_menu->Append(TEX_MODE_RTF, "Output linear &RTF",   "Wordprocessor-compatible RTF");
  357.     mode_menu->Append(TEX_MODE_WINHELP, "Output &WinHelp RTF", "WinHelp-compatible RTF");
  358.     mode_menu->Append(TEX_MODE_HTML, "Output &HTML",        "HTML World Wide Web hypertext file");
  359.     mode_menu->Append(TEX_MODE_XLP, "Output &XLP",          "wxHelp hypertext help file");
  360.  
  361.     wxMenu *options_menu = new wxMenu;
  362.  
  363.     options_menu->Append(TEX_OPTIONS_CURELY_BRACE, "Curley brace matching",   "Checks for mismatched curley braces",TRUE);
  364.     options_menu->Append(TEX_OPTIONS_SYNTAX_CHECKING, "Syntax checking", "Syntax checking for common errors",TRUE);
  365.  
  366.     options_menu->Check(TEX_OPTIONS_CURELY_BRACE, checkCurleyBraces);
  367.     options_menu->Check(TEX_OPTIONS_SYNTAX_CHECKING, checkSyntax);
  368.  
  369.     wxMenu *help_menu = new wxMenu;
  370.  
  371.     help_menu->Append(TEX_HELP, "&Help", "Tex2RTF Contents Page");
  372.     help_menu->Append(TEX_ABOUT, "&About Tex2RTF", "About Tex2RTF");
  373.  
  374.     menuBar = new wxMenuBar;
  375.     menuBar->Append(file_menu, "&File");
  376.     menuBar->Append(macro_menu, "&Macros");
  377.     menuBar->Append(mode_menu, "&Conversion Mode");
  378.     menuBar->Append(options_menu, "&Options");
  379.     menuBar->Append(help_menu, "&Help");
  380.  
  381.     frame->SetMenuBar(menuBar);
  382.     frame->textWindow = new wxTextCtrl(frame, -1, "", wxPoint(-1, -1), wxSize(-1, -1), wxTE_READONLY|wxTE_MULTILINE);
  383.  
  384.     (*frame->textWindow) << "Welcome to Tex2RTF.\n";
  385. //    ShowOptions();
  386.  
  387. #if wxUSE_HELP
  388.     HelpInstance = new wxHelpController();
  389.     HelpInstance->Initialize("tex2rtf");
  390. #endif // wxUSE_HELP
  391.  
  392.     /*
  393.      * Read macro/initialisation file
  394.      *
  395.      */
  396.  
  397.     wxString path;
  398.     if ((path = TexPathList.FindValidPath(MacroFile)) != "")
  399.       ReadCustomMacros((char*) (const char*) path);
  400.  
  401.     strcpy(buf, "In ");
  402.  
  403.     if (winHelp && (convertMode == TEX_RTF))
  404.       strcat(buf, "WinHelp RTF");
  405.     else if (!winHelp && (convertMode == TEX_RTF))
  406.       strcat(buf, "linear RTF");
  407.     else if (convertMode == TEX_HTML) strcat(buf, "HTML");
  408.     else if (convertMode == TEX_XLP) strcat(buf, "XLP");
  409.       strcat(buf, " mode.");
  410.     frame->SetStatusText(buf, 1);
  411.  
  412.     frame->Show(TRUE);
  413.     return TRUE;
  414.   }
  415.   else
  416. #endif // NO_GUI
  417.   {
  418.     /*
  419.      * Read macro/initialisation file
  420.      *
  421.      */
  422.  
  423.     wxString path;
  424.     if ((path = TexPathList.FindValidPath(MacroFile)) != "")
  425.       ReadCustomMacros((char*) (const char*) path);
  426.  
  427.     Go();
  428.     if (runTwice) 
  429.     {
  430.         Go();
  431.     }
  432. #ifdef NO_GUI
  433.     return 0;
  434. #else
  435.     return NULL;
  436. #endif
  437.   }
  438.  
  439. #ifndef NO_GUI
  440.   // Return the main frame window
  441.   return TRUE;
  442. #else
  443.   return FALSE;
  444. #endif
  445. }
  446.  
  447. #ifndef NO_GUI
  448. int MyApp::OnExit()
  449. {
  450.   wxNode *node = CustomMacroList.First();
  451.   while (node)
  452.   {
  453.     CustomMacro *macro = (CustomMacro *)node->Data();
  454.     delete macro;
  455.     delete node;
  456.     node = CustomMacroList.First();
  457.   }
  458.   MacroDefs.BeginFind();
  459.   node = MacroDefs.Next();
  460.   while (node)
  461.   {
  462.     TexMacroDef* def = (TexMacroDef*) node->Data();
  463.     delete def;
  464.     node = MacroDefs.Next();
  465.   }
  466.   MacroDefs.Clear();
  467. #ifdef __WXMSW__
  468.   delete TheTex2RTFServer;
  469.   wxDDECleanUp();
  470. #endif
  471.  
  472. #if wxUSE_HELP
  473.   delete HelpInstance;
  474. #endif // wxUSE_HELP
  475.  
  476.     if (BigBuffer)
  477.     {
  478.       delete BigBuffer;
  479.       BigBuffer = NULL;
  480.     }
  481.     if (currentArgData)
  482.     {
  483.       delete currentArgData;
  484.       currentArgData = NULL;
  485.     }
  486.     if (TexFileRoot)
  487.     {
  488.       delete TexFileRoot;
  489.       TexFileRoot = NULL;
  490.     }
  491.     if (TexBibName)
  492.     {
  493.       delete TexBibName;
  494.       TexBibName = NULL;
  495.     }
  496.     if (TexTmpBibName)
  497.     {
  498.       delete TexTmpBibName;
  499.       TexTmpBibName = NULL;
  500.     }
  501.     if (FileRoot)
  502.     {
  503.       delete FileRoot;
  504.       FileRoot = NULL;
  505.     }
  506.     if (ContentsName)
  507.     {
  508.       delete ContentsName;
  509.       ContentsName = NULL;
  510.     }
  511.     if (TmpContentsName)
  512.     {
  513.       delete TmpContentsName;
  514.       TmpContentsName = NULL;
  515.     }
  516.     if (TmpFrameContentsName)
  517.     {
  518.       delete TmpFrameContentsName;
  519.       TmpFrameContentsName = NULL;
  520.     }
  521.     if (WinHelpContentsFileName)
  522.     {
  523.       delete WinHelpContentsFileName;
  524.       WinHelpContentsFileName = NULL;
  525.     }
  526.     if (RefFileName)
  527.     {
  528.       delete RefFileName;
  529.       RefFileName = NULL;
  530.     }
  531.     if (TopLevel)
  532.     {
  533.       delete TopLevel;
  534.       TopLevel = NULL;
  535.     }
  536.     if (MacroFile)
  537.     {
  538.       delete MacroFile;
  539.       MacroFile = NULL;
  540.     }
  541.     if (RTFCharset)
  542.     {
  543.       delete RTFCharset;
  544.       RTFCharset = NULL;
  545.     }
  546.  
  547.     delete [] PageStyle;
  548.     delete [] BibliographyStyleString;
  549.     delete [] DocumentStyleString;
  550.     delete [] bitmapMethod;
  551.     delete [] backgroundColourString;
  552.     delete [] ContentsNameString;
  553.     delete [] AbstractNameString;
  554.     delete [] GlossaryNameString;
  555.     delete [] ReferencesNameString;
  556.     delete [] FiguresNameString;
  557.     delete [] TablesNameString;
  558.     delete [] FigureNameString;
  559.     delete [] TableNameString;
  560.     delete [] IndexNameString;
  561.     delete [] ChapterNameString;
  562.     delete [] SectionNameString;
  563.     delete [] SubsectionNameString;
  564.     delete [] SubsubsectionNameString;
  565.     delete [] UpNameString;
  566.     if (winHelpTitle)
  567.       delete[] winHelpTitle;
  568.  
  569.   // TODO: this simulates zero-memory leaks!
  570.   // Otherwise there are just too many...
  571. #ifndef __WXGTK__
  572. #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
  573.   wxDebugContext::SetCheckpoint();
  574. #endif
  575. #endif
  576.  
  577.   return 0;
  578. }
  579. #endif
  580. void ShowOptions(void)
  581. {
  582.     char buf[100];
  583.     sprintf(buf, "Tex2RTF version %.2f", versionNo);
  584.     OnInform(buf);
  585.     OnInform("Usage: tex2rtf [input] [output] [switches]\n");
  586.     OnInform("where valid switches are");
  587. #ifndef NO_GUI
  588.     OnInform("    -interactive");
  589. #endif
  590.     OnInform("    -bufsize <size in K>");
  591.     OnInform("    -charset <pc | pca | ansi | mac> (default ansi)");
  592.     OnInform("    -twice");
  593.     OnInform("    -sync");
  594.     OnInform("    -checkcurleybraces");
  595.     OnInform("    -checksyntax");
  596.     OnInform("    -macros <filename>");
  597.     OnInform("    -winhelp");
  598.     OnInform("    -rtf");
  599.     OnInform("    -html");
  600.     OnInform("    -xlp\n");
  601. }
  602.  
  603. #ifndef NO_GUI
  604.  
  605. BEGIN_EVENT_TABLE(MyFrame, wxFrame)
  606.     EVT_CLOSE(MyFrame::OnCloseWindow)
  607.     EVT_MENU(TEX_QUIT, MyFrame::OnExit)
  608.     EVT_MENU(TEX_GO, MyFrame::OnGo)
  609.     EVT_MENU(TEX_SET_INPUT, MyFrame::OnSetInput)
  610.     EVT_MENU(TEX_SET_OUTPUT, MyFrame::OnSetOutput)
  611.     EVT_MENU(TEX_SAVE_FILE, MyFrame::OnSaveFile)
  612.     EVT_MENU(TEX_VIEW_LATEX, MyFrame::OnViewLatex)
  613.     EVT_MENU(TEX_VIEW_OUTPUT, MyFrame::OnViewOutput)
  614.     EVT_MENU(TEX_VIEW_CUSTOM_MACROS, MyFrame::OnShowMacros)
  615.     EVT_MENU(TEX_LOAD_CUSTOM_MACROS, MyFrame::OnLoadMacros)
  616.     EVT_MENU(TEX_MODE_RTF, MyFrame::OnModeRTF)
  617.     EVT_MENU(TEX_MODE_WINHELP, MyFrame::OnModeWinHelp)
  618.     EVT_MENU(TEX_MODE_HTML, MyFrame::OnModeHTML)
  619.     EVT_MENU(TEX_MODE_XLP, MyFrame::OnModeXLP)
  620.     EVT_MENU(TEX_OPTIONS_CURELY_BRACE, MyFrame::OnOptionsCurleyBrace)
  621.     EVT_MENU(TEX_OPTIONS_SYNTAX_CHECKING, MyFrame::OnOptionsSyntaxChecking)
  622.     EVT_MENU(TEX_HELP, MyFrame::OnHelp)
  623.     EVT_MENU(TEX_ABOUT, MyFrame::OnAbout)
  624. END_EVENT_TABLE()
  625.  
  626. // My frame constructor
  627. MyFrame::MyFrame(wxFrame *frame, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size):
  628.   wxFrame(frame, id, title, pos, size)
  629. {}
  630.  
  631. void MyFrame::OnCloseWindow(wxCloseEvent& event)
  632. {
  633.   if (!stopRunning && !OkToClose)
  634.   {
  635.     stopRunning = TRUE;
  636.     runTwice = FALSE;
  637.     return;
  638.   }
  639.   else if (OkToClose)
  640.   {
  641.     this->Destroy();
  642.   }
  643. }
  644.  
  645. void MyFrame::OnExit(wxCommandEvent& event)
  646. {
  647.   Close();
  648. //    this->Destroy();
  649. }
  650.  
  651. void MyFrame::OnGo(wxCommandEvent& event)
  652. {
  653.       passNumber = 1;
  654.       errorCount = 0;
  655.       menuBar->EnableTop(0, FALSE);
  656.       menuBar->EnableTop(1, FALSE);
  657.       menuBar->EnableTop(2, FALSE);
  658.       menuBar->EnableTop(3, FALSE);
  659.       textWindow->Clear();
  660.       Tex2RTFYield(TRUE);
  661.       Go();
  662.  
  663.       if (stopRunning)
  664.       {
  665.         SetStatusText("Build aborted!");
  666.         wxString errBuf;
  667.         errBuf.Printf("\nErrors encountered during this pass: %lu\n", errorCount);
  668.         OnInform((char *)errBuf.c_str());
  669.       }
  670.  
  671.  
  672.       if (runTwice && !stopRunning)
  673.       {
  674.         Tex2RTFYield(TRUE);
  675.         Go();
  676.       }
  677.       menuBar->EnableTop(0, TRUE);
  678.       menuBar->EnableTop(1, TRUE);
  679.       menuBar->EnableTop(2, TRUE);
  680.       menuBar->EnableTop(3, TRUE);
  681. }
  682.  
  683. void MyFrame::OnSetInput(wxCommandEvent& event)
  684. {
  685.       ChooseInputFile(TRUE);
  686. }
  687.  
  688. void MyFrame::OnSetOutput(wxCommandEvent& event)
  689. {
  690.       ChooseOutputFile(TRUE);
  691. }
  692.  
  693. void MyFrame::OnSaveFile(wxCommandEvent& event)
  694. {
  695.       wxString s = wxFileSelector("Save text to file", "", "", "txt", "*.txt");
  696.       if (s != "")
  697.       {
  698.         textWindow->SaveFile(s);
  699.         char buf[350];
  700.         sprintf(buf, "Saved text to %s", (const char*) s);
  701.         frame->SetStatusText(buf, 0);
  702.       }
  703. }
  704.  
  705. void MyFrame::OnViewOutput(wxCommandEvent& event)
  706. {
  707.       ChooseOutputFile();
  708.       if (OutputFile && wxFileExists(OutputFile))
  709.       {
  710.         textWindow->LoadFile(OutputFile);
  711.         char buf[300];
  712.         wxString str(wxFileNameFromPath(OutputFile));
  713.         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
  714.         frame->SetTitle(buf);
  715.       }
  716. }
  717.  
  718. void MyFrame::OnViewLatex(wxCommandEvent& event)
  719. {
  720.       ChooseInputFile();
  721.       if (InputFile && wxFileExists(InputFile))
  722.       {
  723.         textWindow->LoadFile(InputFile);
  724.         char buf[300];
  725.         wxString str(wxFileNameFromPath(OutputFile));
  726.         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
  727.         frame->SetTitle(buf);
  728.       }
  729. }
  730.  
  731. void MyFrame::OnLoadMacros(wxCommandEvent& event)
  732. {
  733.       textWindow->Clear();
  734.       wxString s = wxFileSelector("Choose custom macro file", wxPathOnly(MacroFile), wxFileNameFromPath(MacroFile), "ini", "*.ini");
  735.       if (s != "" && wxFileExists(s))
  736.       {
  737.         MacroFile = copystring(s);
  738.         ReadCustomMacros((char*) (const char*) s);
  739.         ShowCustomMacros();
  740.       }
  741. }
  742.  
  743. void MyFrame::OnShowMacros(wxCommandEvent& event)
  744. {
  745.       textWindow->Clear();
  746.       Tex2RTFYield(TRUE);
  747.       ShowCustomMacros();
  748. }
  749.  
  750. void MyFrame::OnModeRTF(wxCommandEvent& event)
  751. {
  752.       convertMode = TEX_RTF;
  753.       winHelp = FALSE;
  754.       InputFile = NULL;
  755.       OutputFile = NULL;
  756.       SetStatusText("In linear RTF mode.", 1);
  757. }
  758.  
  759. void MyFrame::OnModeWinHelp(wxCommandEvent& event)
  760. {
  761.       convertMode = TEX_RTF;
  762.       winHelp = TRUE;
  763.       InputFile = NULL;
  764.       OutputFile = NULL;
  765.       SetStatusText("In WinHelp RTF mode.", 1);
  766. }
  767.  
  768. void MyFrame::OnModeHTML(wxCommandEvent& event)
  769. {
  770.       convertMode = TEX_HTML;
  771.       winHelp = FALSE;
  772.       InputFile = NULL;
  773.       OutputFile = NULL;
  774.       SetStatusText("In HTML mode.", 1);
  775. }
  776.  
  777. void MyFrame::OnModeXLP(wxCommandEvent& event)
  778. {
  779.       convertMode = TEX_XLP;
  780.       InputFile = NULL;
  781.       OutputFile = NULL;
  782.       SetStatusText("In XLP mode.", 1);
  783. }
  784.  
  785. void MyFrame::OnOptionsCurleyBrace(wxCommandEvent& event)
  786. {
  787.     checkCurleyBraces = !checkCurleyBraces;
  788.     if (checkCurleyBraces)
  789.     {
  790.         SetStatusText("Checking curley braces: YES", 1);
  791.     }
  792.     else
  793.     {
  794.         SetStatusText("Checking curley braces: NO", 1);
  795.     }
  796. }
  797.  
  798.  
  799. void MyFrame::OnOptionsSyntaxChecking(wxCommandEvent& event)
  800. {
  801.     checkSyntax = !checkSyntax;
  802.     if (checkSyntax)
  803.     {
  804.         SetStatusText("Checking syntax: YES", 1);
  805.     }
  806.     else
  807.     {
  808.         SetStatusText("Checking syntax: NO", 1);
  809.     }
  810. }
  811.  
  812.  
  813. void MyFrame::OnHelp(wxCommandEvent& event)
  814. {
  815. #if wxUSE_HELP
  816.       HelpInstance->LoadFile();
  817.       HelpInstance->DisplayContents();
  818. #endif // wxUSE_HELP
  819. }
  820.  
  821. void MyFrame::OnAbout(wxCommandEvent& event)
  822. {
  823.       char buf[300];
  824. #ifdef __WIN32__
  825.       char *platform = " (32-bit)";
  826. #else
  827. #ifdef __WXMSW__
  828.       char *platform = " (16-bit)";
  829. #else
  830.       char *platform = "";
  831. #endif
  832. #endif
  833.       sprintf(buf, "Tex2RTF Version %.2f%s\nLaTeX to RTF, WinHelp, and HTML Conversion\n\n(c) Julian Smart, George Tasker and others, 1999-2002", versionNo, platform);
  834.       wxMessageBox(buf, "About Tex2RTF");
  835. }
  836.  
  837. void ChooseInputFile(bool force)
  838. {
  839.   if (force || !InputFile)
  840.   {
  841.     wxString s = wxFileSelector("Choose LaTeX input file", wxPathOnly(InputFile), wxFileNameFromPath(InputFile), "tex", "*.tex");
  842.     if (s != "")
  843.     {
  844.       // Different file, so clear index entries.
  845.       ClearKeyWordTable();
  846.       ResetContentsLevels(0);
  847.       passNumber = 1;
  848.       errorCount = 0;
  849.  
  850.       InputFile = copystring(s);
  851.       wxString str = wxFileNameFromPath(InputFile);
  852.       wxString buf;
  853.       buf.Printf("Tex2RTF [%s]", str.c_str());
  854.       frame->SetTitle((char *)buf.c_str());
  855.       OutputFile = NULL;
  856.     }
  857.   }
  858. }
  859.  
  860. void ChooseOutputFile(bool force)
  861. {
  862.   char extensionBuf[10];
  863.   char wildBuf[10];
  864.   strcpy(wildBuf, "*.");
  865.   wxString path;
  866.   if (OutputFile)
  867.     path = wxPathOnly(OutputFile);
  868.   else if (InputFile)
  869.     path = wxPathOnly(InputFile);
  870.  
  871.   switch (convertMode)
  872.   {
  873.     case TEX_RTF:
  874.     {
  875.       strcpy(extensionBuf, "rtf");
  876.       strcat(wildBuf, "rtf");
  877.       break;
  878.     }
  879.     case TEX_XLP:
  880.     {
  881.       strcpy(extensionBuf, "xlp");
  882.       strcat(wildBuf, "xlp");
  883.       break;
  884.     }
  885.     case TEX_HTML:
  886.     {
  887. #if defined(__WXMSW__) && defined(__WIN16__)
  888.       strcpy(extensionBuf, "htm");
  889.       strcat(wildBuf, "htm");
  890. #else
  891.       strcpy(extensionBuf, "html");
  892.       strcat(wildBuf, "html");
  893. #endif
  894.       break;
  895.     }
  896.   }
  897.   if (force || !OutputFile)
  898.   {
  899.     wxString s = wxFileSelector("Choose output file", path, wxFileNameFromPath(OutputFile),
  900.                    extensionBuf, wildBuf);
  901.     if (s != "")
  902.       OutputFile = copystring(s);
  903.   }
  904. }
  905. #endif
  906.  
  907. bool Go(void)
  908. {
  909. #ifndef NO_GUI
  910.   ChooseInputFile();
  911.   ChooseOutputFile();
  912. #endif
  913.  
  914.   if (!InputFile || !OutputFile || stopRunning)
  915.     return FALSE;
  916.  
  917. #ifndef NO_GUI
  918.   if (isInteractive)
  919.   {
  920.     char buf[300];
  921.     wxString str = wxFileNameFromPath(InputFile);
  922.  
  923.     sprintf(buf, "Tex2RTF [%s]", (const char*) str);
  924.     frame->SetTitle(buf);
  925.   }
  926.  
  927.   wxStartTimer();
  928. #endif
  929.  
  930.   // Find extension-less filename
  931.   strcpy(FileRoot, OutputFile);
  932.   StripExtension(FileRoot);
  933.  
  934.   if (truncateFilenames && convertMode == TEX_HTML)
  935.   {
  936.     // Truncate to five characters. This ensures that
  937.     // we can generate DOS filenames such as thing999. But 1000 files
  938.     // may not be enough, of course...
  939.     char* sName = wxFileNameFromPath( FileRoot);  // this Julian's method is non-destructive reference
  940.  
  941.     if(sName)
  942.       if(strlen( sName) > 5)
  943.         sName[5] = '\0';  // that should do!
  944.   }
  945.  
  946.   sprintf(ContentsName, "%s.con", FileRoot);
  947.   sprintf(TmpContentsName, "%s.cn1", FileRoot);
  948.   sprintf(TmpFrameContentsName, "%s.frc", FileRoot);
  949.   sprintf(WinHelpContentsFileName, "%s.cnt", FileRoot);
  950.   sprintf(RefFileName, "%s.ref", FileRoot);
  951.  
  952.   TexPathList.EnsureFileAccessible(InputFile);
  953.   if (!bulletFile)
  954.   {
  955.     wxString s = TexPathList.FindValidPath("bullet.bmp");
  956.     if (s != "")
  957.     {
  958.       wxString str = wxFileNameFromPath(s);
  959.       bulletFile = copystring(str);
  960.     }
  961.   }
  962.  
  963.   if (wxFileExists(RefFileName))
  964.     ReadTexReferences(RefFileName);
  965.  
  966.   bool success = FALSE;
  967.  
  968.   if (InputFile && OutputFile)
  969.   {
  970.     if (!FileExists(InputFile))
  971.     {
  972.       OnError("Cannot open input file!");
  973.       TexCleanUp();
  974.       return FALSE;
  975.     }
  976. #ifndef NO_GUI
  977.     if (isInteractive)
  978.     {
  979.       wxString buf;
  980.       buf.Printf("Working, pass %d...Click CLOSE to abort", passNumber);
  981.       frame->SetStatusText((char *)buf.c_str());
  982.     }
  983. #endif
  984.     OkToClose = FALSE;
  985.     OnInform("Reading LaTeX file...");
  986.     TexLoadFile(InputFile);
  987.  
  988.     if (stopRunning)
  989.     {
  990.         OkToClose = TRUE;
  991.         return FALSE;
  992.     }
  993.  
  994.     switch (convertMode)
  995.     {
  996.       case TEX_RTF:
  997.       {
  998.         success = RTFGo();
  999.         break;
  1000.       }
  1001.       case TEX_XLP:
  1002.       {
  1003.         success = XLPGo();
  1004.         break;
  1005.       }
  1006.       case TEX_HTML:
  1007.       {
  1008.         success = HTMLGo();
  1009.         break;
  1010.       }
  1011.     }
  1012.   }
  1013.   if (stopRunning)
  1014.   {
  1015.     OnInform("*** Aborted by user.");
  1016.     success = FALSE;
  1017.     stopRunning = FALSE;
  1018.     OkToClose = TRUE;
  1019.   }
  1020.  
  1021.   if (success)
  1022.   {
  1023.     WriteTexReferences(RefFileName);
  1024.     TexCleanUp();
  1025.     startedSections = FALSE;
  1026.  
  1027.     wxString buf;
  1028. #ifndef NO_GUI
  1029.     long tim = wxGetElapsedTime();
  1030.     buf.Printf("Finished PASS #%d in %ld seconds.\n", passNumber, (long)(tim/1000.0));
  1031.     OnInform((char *)buf.c_str());
  1032.  
  1033.     if (errorCount)
  1034.     {
  1035.         buf.Printf("Errors encountered during this pass: %lu\n", errorCount);
  1036.         OnInform((char *)buf.c_str());
  1037.     }
  1038.  
  1039.     if (isInteractive)
  1040.     {
  1041.       buf.Printf("Done, %d %s.", passNumber, (passNumber > 1) ? "passes" : "pass");
  1042.       frame->SetStatusText((char *)buf.c_str());
  1043.     }
  1044. #else
  1045.     buf.Printf("Done, %d %s.", passNumber, (passNumber > 1) ? "passes" : "pass");
  1046.     OnInform((char *)buf.c_str());
  1047.     if (errorCount)
  1048.     {
  1049.         buf.Printf("Errors encountered during this pass: %lu\n", errorCount);
  1050.         OnInform((char *)buf.c_str());
  1051.     }
  1052. #endif
  1053.     passNumber ++;
  1054.     errorCount = 0;
  1055.     OkToClose = TRUE;
  1056.     return TRUE;
  1057.   }
  1058.  
  1059.   TexCleanUp();
  1060.   startedSections = FALSE;
  1061.  
  1062. #ifndef NO_GUI
  1063.   frame->SetStatusText("Aborted by user.");
  1064. #endif // GUI
  1065.  
  1066.   OnInform("Sorry, unsuccessful.");
  1067.   OkToClose = TRUE;
  1068.   return FALSE;
  1069. }
  1070.  
  1071. void OnError(const char *msg)
  1072. {
  1073.   errorCount++;
  1074.  
  1075. #ifdef NO_GUI
  1076.   wxSTD cerr << "Error: " << msg << "\n";
  1077.   wxSTD cerr.flush();
  1078. #else
  1079.   if (isInteractive && frame)
  1080.     (*frame->textWindow) << "Error: " << msg << "\n";
  1081.   else
  1082. #ifdef __UNIX__
  1083.   {
  1084.     wxSTD cerr << "Error: " << msg << "\n";
  1085.     wxSTD cerr.flush();
  1086.   }
  1087. #endif
  1088.  
  1089. #ifdef __WXMSW__
  1090.     wxLogError(msg);
  1091. #endif
  1092.   Tex2RTFYield(TRUE);
  1093. #endif // NO_GUI
  1094. }
  1095.  
  1096. void OnInform(const char *msg)
  1097. {
  1098. #ifdef NO_GUI
  1099.   wxSTD cout << msg << "\n";
  1100.   wxSTD cout.flush();
  1101. #else
  1102.   if (isInteractive && frame)
  1103.     (*frame->textWindow) << msg << "\n";
  1104. /* This whole block of code is just wrong I think.  It would behave
  1105.    completely wrong under anything other than MSW due to the ELSE
  1106.     with no statement, and the cout calls would fail under MSW, as
  1107.     the code in this block is compiled if !NO_GUI This code has been 
  1108.     here since v1.1 of this file too. - gt
  1109.   else
  1110. #ifdef __WXMSW__
  1111.   {
  1112.     wxSTD cout << msg << "\n";
  1113.     wxSTD cout.flush();
  1114.   }
  1115. #endif
  1116. #ifdef __WXMSW__
  1117.     {}
  1118. #endif
  1119. */
  1120.   if (isInteractive)
  1121.   {
  1122.     Tex2RTFYield(TRUE);
  1123.   }
  1124. #endif // NO_GUI
  1125. }
  1126.  
  1127. void OnMacro(int macroId, int no_args, bool start)
  1128. {
  1129.   switch (convertMode)
  1130.   {
  1131.     case TEX_RTF:
  1132.     {
  1133.       RTFOnMacro(macroId, no_args, start);
  1134.       break;
  1135.     }
  1136.     case TEX_XLP:
  1137.     {
  1138.       XLPOnMacro(macroId, no_args, start);
  1139.       break;
  1140.     }
  1141.     case TEX_HTML:
  1142.     {
  1143.       HTMLOnMacro(macroId, no_args, start);
  1144.       break;
  1145.     }
  1146.   }
  1147. }
  1148.  
  1149. bool OnArgument(int macroId, int arg_no, bool start)
  1150. {
  1151.   switch (convertMode)
  1152.   {
  1153.     case TEX_RTF:
  1154.     {
  1155.       return RTFOnArgument(macroId, arg_no, start);
  1156.       break;
  1157.     }
  1158.     case TEX_XLP:
  1159.     {
  1160.       return XLPOnArgument(macroId, arg_no, start);
  1161.       break;
  1162.     }
  1163.     case TEX_HTML:
  1164.     {
  1165.       return HTMLOnArgument(macroId, arg_no, start);
  1166.       break;
  1167.     }
  1168.   }
  1169.   return TRUE;
  1170. }
  1171.  
  1172. /*
  1173.  * DDE Stuff
  1174.  */
  1175. #if defined(__WXMSW__) && !defined(NO_GUI)
  1176.  
  1177. /*
  1178.  * Server
  1179.  */
  1180.  
  1181. wxConnectionBase *Tex2RTFServer::OnAcceptConnection(const wxString& topic)
  1182. {
  1183.   if (topic == "TEX2RTF")
  1184.   {
  1185.     if (!ipc_buffer)
  1186.       ipc_buffer = new char[1000];
  1187.  
  1188.     return new Tex2RTFConnection(ipc_buffer, 4000);
  1189.   }
  1190.   else
  1191.     return NULL;
  1192. }
  1193.  
  1194.  /*
  1195.   * Connection
  1196.   */
  1197.  
  1198. Tex2RTFConnection::Tex2RTFConnection(char *buf, int size):wxDDEConnection(buf, size)
  1199. {
  1200. }
  1201.  
  1202. Tex2RTFConnection::~Tex2RTFConnection(void)
  1203. {
  1204. }
  1205.  
  1206. bool SplitCommand(char *data, char *firstArg, char *secondArg)
  1207. {
  1208.   firstArg[0] = 0;
  1209.   secondArg[0] = 0;
  1210.   int i = 0;
  1211.   int len = strlen(data);
  1212.   bool stop = FALSE;
  1213.   // Find first argument (command name)
  1214.   while (!stop)
  1215.   {
  1216.     if (data[i] == ' ' || data[i] == 0)
  1217.       stop = TRUE;
  1218.     else
  1219.     {
  1220.       firstArg[i] = data[i];
  1221.       i ++;
  1222.     }
  1223.   }
  1224.   firstArg[i] = 0;
  1225.   if (data[i] == ' ')
  1226.   {
  1227.     // Find second argument
  1228.     i ++;
  1229.     int j = 0;
  1230.     while (data[i] != 0)
  1231.     {
  1232.       secondArg[j] = data[i];
  1233.       i ++;
  1234.       j ++;
  1235.     }
  1236.     secondArg[j] = 0;
  1237.   }
  1238.   return TRUE;
  1239. }
  1240.  
  1241. bool Tex2RTFConnection::OnExecute(const wxString& topic, char *data, int size, int format)
  1242. {
  1243.   strcpy(Tex2RTFLastStatus, "OK");
  1244.  
  1245.   char firstArg[50];
  1246.   char secondArg[300];
  1247.   if (SplitCommand(data, firstArg, secondArg))
  1248.   {
  1249.     bool hasArg = (strlen(secondArg) > 0);
  1250.     if (strcmp(firstArg, "INPUT") == 0 && hasArg)
  1251.     {
  1252.       if (InputFile) delete[] InputFile;
  1253.       InputFile = copystring(secondArg);
  1254.       if (frame)
  1255.       {
  1256.         char buf[100];
  1257.         wxString str = wxFileNameFromPath(InputFile);
  1258.         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
  1259.         frame->SetTitle(buf);
  1260.       }
  1261.     }
  1262.     else if (strcmp(firstArg, "OUTPUT") == 0 && hasArg)
  1263.     {
  1264.       if (OutputFile) delete[] OutputFile;
  1265.       OutputFile = copystring(secondArg);
  1266.     }
  1267.     else if (strcmp(firstArg, "GO") == 0)
  1268.     {
  1269.       strcpy(Tex2RTFLastStatus, "WORKING");
  1270.       if (!Go())
  1271.         strcpy(Tex2RTFLastStatus, "CONVERSION ERROR");
  1272.       else
  1273.         strcpy(Tex2RTFLastStatus, "OK");
  1274.     }
  1275.     else if (strcmp(firstArg, "EXIT") == 0)
  1276.     {
  1277.       if (frame) frame->Close();
  1278.     }
  1279.     else if (strcmp(firstArg, "MINIMIZE") == 0 || strcmp(firstArg, "ICONIZE") == 0)
  1280.     {
  1281.       if (frame)
  1282.         frame->Iconize(TRUE);
  1283.     }
  1284.     else if (strcmp(firstArg, "SHOW") == 0 || strcmp(firstArg, "RESTORE") == 0)
  1285.     {
  1286.       if (frame)
  1287.       {
  1288.         frame->Iconize(FALSE);
  1289.         frame->Show(TRUE);
  1290.       }
  1291.     }
  1292.     else
  1293.     {
  1294.       // Try for a setting
  1295.       strcpy(Tex2RTFLastStatus, RegisterSetting(firstArg, secondArg, FALSE));
  1296. #ifndef NO_GUI
  1297.       if (frame && strcmp(firstArg, "conversionMode") == 0)
  1298.       {
  1299.         char buf[100];
  1300.         strcpy(buf, "In ");
  1301.  
  1302.         if (winHelp && (convertMode == TEX_RTF))
  1303.           strcat(buf, "WinHelp RTF");
  1304.         else if (!winHelp && (convertMode == TEX_RTF))
  1305.           strcat(buf, "linear RTF");
  1306.         else if (convertMode == TEX_HTML) strcat(buf, "HTML");
  1307.         else if (convertMode == TEX_XLP) strcat(buf, "XLP");
  1308.           strcat(buf, " mode.");
  1309.         frame->SetStatusText(buf, 1);
  1310.       }
  1311. #endif
  1312.     }
  1313.   }
  1314.   return TRUE;
  1315. }
  1316.  
  1317. char *Tex2RTFConnection::OnRequest(const wxString& topic, const wxString& item, int *size, int format)
  1318. {
  1319.   return Tex2RTFLastStatus;
  1320. }
  1321.  
  1322. #endif
  1323.  
  1324. #ifndef NO_GUI
  1325. #ifndef __WXGTK__
  1326. //void wxObject::Dump(wxSTD ostream& str)
  1327. //{
  1328. //  if (GetClassInfo() && GetClassInfo()->GetClassName())
  1329. //    str << GetClassInfo()->GetClassName();
  1330. //  else
  1331. //    str << "unknown object class";
  1332. //}
  1333. #endif
  1334. #endif
  1335.