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