utils/tex2rtf/src/tex2rtf.cpp

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