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 #ifdef NO_GUI
  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
  61 #ifndef NO_GUI
  62 wxHelpController *HelpInstance = NULL;
  63
  64 #ifdef __WXMSW__
  65 static char *ipc_buffer = NULL;
  66 static char Tex2RTFLastStatus[100];
  67 Tex2RTFServer *TheTex2RTFServer = NULL;
  68 #endif
  69 #endif
  70
  71 char *bulletFile = NULL;
  72
  73 FILE *Contents = NULL;   // Contents page
  74 FILE *Chapters = NULL;   // Chapters (WinHelp RTF) or rest of file (linear RTF)
  75 FILE *Sections = NULL;
  76 FILE *Subsections = NULL;
  77 FILE *Subsubsections = NULL;
  78 FILE *Popups = NULL;
  79 FILE *WinHelpContentsFile = NULL;
  80
  81 char *InputFile = NULL;
  82 char *OutputFile = NULL;
  83 char *MacroFile = copystring("tex2rtf.ini");
  84
  85 char *FileRoot = NULL;
  86 char *ContentsName = NULL;    // Contents page from last time around
  87 char *TmpContentsName = NULL; // Current contents page
  88 char *TmpFrameContentsName = NULL; // Current frame contents page
  89 char *WinHelpContentsFileName = NULL; // WinHelp .cnt file
  90 char *RefName = NULL;         // Reference file name
  91
  92 char *RTFCharset = copystring("ansi");
  93
  94 #ifdef __WXMSW__
  95 int BufSize = 100;             // Size of buffer in K
  96 #else
  97 int BufSize = 500;
  98 #endif
  99
 100 bool Go(void);
 101 void ShowOptions(void);
 102
 103 #ifdef NO_GUI
 104 int main(int argc, char **argv)
 105 #else
 106 wxMenuBar *menuBar = NULL;
 107 MyFrame *frame = NULL;
 108
 109 // DECLARE_APP(MyApp)
 110 IMPLEMENT_APP(MyApp)
 111
 112 // `Main program' equivalent, creating windows and returning main app frame
 113 bool MyApp::OnInit()
 114 #endif
 115 {
 116   // Use default list of macros defined in tex2any.cc
 117   DefineDefaultMacros();
 118   AddMacroDef(ltHARDY, "hardy", 0);
 119
 120   FileRoot = new char[300];
 121   ContentsName = new char[300];
 122   TmpContentsName = new char[300];
 123   TmpFrameContentsName = new char[300];
 124   WinHelpContentsFileName = new char[300];
 125   RefName = new char[300];
 126
 127   int n = 1;
 128
 129   // Read input/output files
 130   if (argc > 1)
 131   {
 132     if (argv[1][0] != '-')
 133     {
 134       InputFile = argv[1];
 135       n ++;
 136
 137       if (argc > 2)
 138       {
 139         if (argv[2][0] != '-')
 140         {
 141           OutputFile = argv[2];
 142           n ++;
 143         }
 144       }
 145     }
 146   }
 147
 148 #ifdef NO_GUI
 149   if (!InputFile || !OutputFile)
 150   {
 151     cout << "Tex2RTF: input or output file is missing.\n";
 152     ShowOptions();
 153     exit(1);
 154   }
 155 #endif
 156   if (InputFile)
 157   {
 158     TexPathList.EnsureFileAccessible(InputFile);
 159   }
 160   if (!InputFile || !OutputFile)
 161     isInteractive = TRUE;
 162
 163   for (int i = n; i < argc;)
 164   {
 165     if (strcmp(argv[i], "-winhelp") == 0)
 166     {
 167       i ++;
 168       convertMode = TEX_RTF;
 169       winHelp = TRUE;
 170     }
 171 #ifndef NO_GUI
 172     else if (strcmp(argv[i], "-interactive") == 0)
 173     {
 174       i ++;
 175       isInteractive = TRUE;
 176     }
 177 #endif
 178     else if (strcmp(argv[i], "-sync") == 0)  // Don't yield
 179     {
 180       i ++;
 181       isSync = TRUE;
 182     }
 183     else if (strcmp(argv[i], "-rtf") == 0)
 184     {
 185       i ++;
 186       convertMode = TEX_RTF;
 187     }
 188     else if (strcmp(argv[i], "-html") == 0)
 189     {
 190       i ++;
 191       convertMode = TEX_HTML;
 192     }
 193     else if (strcmp(argv[i], "-xlp") == 0)
 194     {
 195       i ++;
 196       convertMode = TEX_XLP;
 197     }
 198     else if (strcmp(argv[i], "-twice") == 0)
 199     {
 200       i ++;
 201       runTwice = TRUE;
 202     }
 203     else if (strcmp(argv[i], "-macros") == 0)
 204     {
 205       i ++;
 206       if (i < argc)
 207       {
 208         MacroFile = copystring(argv[i]);
 209         i ++;
 210       }
 211     }
 212     else if (strcmp(argv[i], "-bufsize") == 0)
 213     {
 214       i ++;
 215       if (i < argc)
 216       {
 217         BufSize = atoi(argv[i]);
 218         i ++;
 219       }
 220     }
 221     else if (strcmp(argv[i], "-charset") == 0)
 222     {
 223       i ++;
 224       if (i < argc)
 225       {
 226         char *s = argv[i];
 227         i ++;
 228         if (strcmp(s, "ansi") == 0 || strcmp(s, "pc") == 0 || strcmp(s, "mac") == 0 ||
 229             strcmp(s, "pca") == 0)
 230           RTFCharset = copystring(s);
 231         else
 232         {
 233           OnError("Incorrect argument for -charset");
 234         }
 235       }
 236     }
 237     else
 238     {
 239       char buf[100];
 240       sprintf(buf, "Invalid switch %s.\n", argv[i]);
 241       OnError(buf);
 242       i++;
 243 #ifdef NO_GUI
 244       ShowOptions();
 245       exit(1);
 246 #endif
 247     }
 248   }
 249
 250 #if defined(__WXMSW__) && !defined(NO_GUI)
 251   wxDDEInitialize();
 252   Tex2RTFLastStatus[0] = 0; // DDE connection return value
 253   TheTex2RTFServer = new Tex2RTFServer;
 254   TheTex2RTFServer->Create("TEX2RTF");
 255 #endif
 256
 257 #if defined(__WXMSW__) && defined(__WIN16__)
 258   // Limit to max Windows array size
 259   if (BufSize > 64) BufSize = 64;
 260 #endif
 261
 262   TexInitialize(BufSize);
 263   ResetContentsLevels(0);
 264
 265 #ifndef NO_GUI
 266
 267   if (isInteractive)
 268   {
 269     char buf[100];
 270
 271     // Create the main frame window
 272     frame = new MyFrame(NULL, -1, "Tex2RTF", wxPoint(-1, -1), wxSize(400, 300));
 273     frame->CreateStatusBar(2);
 274
 275     // Give it an icon
 276     // TODO: uncomment this when we have tex2rtf.xpm
 277     frame->SetIcon(wxICON(tex2rtf));
 278
 279     if (InputFile)
 280     {
 281       sprintf(buf, "Tex2RTF [%s]", FileNameFromPath(InputFile));
 282       frame->SetTitle(buf);
 283     }
 284
 285     // Make a menubar
 286     wxMenu *file_menu = new wxMenu;
 287     file_menu->Append(TEX_GO, "&Go",                        "Run converter");
 288     file_menu->Append(TEX_SET_INPUT, "Set &Input File",     "Set the LaTeX input file");
 289     file_menu->Append(TEX_SET_OUTPUT, "Set &Output File",   "Set the output file");
 290     file_menu->AppendSeparator();
 291     file_menu->Append(TEX_VIEW_LATEX, "View &LaTeX File",   "View the LaTeX input file");
 292     file_menu->Append(TEX_VIEW_OUTPUT, "View Output &File", "View output file");
 293     file_menu->Append(TEX_SAVE_FILE, "&Save log file", "Save displayed text into file");
 294     file_menu->AppendSeparator();
 295     file_menu->Append(TEX_QUIT, "E&xit",                    "Exit Tex2RTF");
 296
 297     wxMenu *macro_menu = new wxMenu;
 298
 299     macro_menu->Append(TEX_LOAD_CUSTOM_MACROS, "&Load Custom Macros", "Load custom LaTeX macro file");
 300     macro_menu->Append(TEX_VIEW_CUSTOM_MACROS, "View &Custom Macros", "View custom LaTeX macros");
 301
 302     wxMenu *mode_menu = new wxMenu;
 303
 304     mode_menu->Append(TEX_MODE_RTF, "Output linear &RTF",   "Wordprocessor-compatible RTF");
 305     mode_menu->Append(TEX_MODE_WINHELP, "Output &WinHelp RTF", "WinHelp-compatible RTF");
 306     mode_menu->Append(TEX_MODE_HTML, "Output &HTML",        "HTML World Wide Web hypertext file");
 307     mode_menu->Append(TEX_MODE_XLP, "Output &XLP",          "wxHelp hypertext help file");
 308
 309     wxMenu *help_menu = new wxMenu;
 310
 311     help_menu->Append(TEX_HELP, "&Help", "Tex2RTF Contents Page");
 312     help_menu->Append(TEX_ABOUT, "&About Tex2RTF", "About Tex2RTF");
 313
 314     menuBar = new wxMenuBar;
 315     menuBar->Append(file_menu, "&File");
 316     menuBar->Append(macro_menu, "&Macros");
 317     menuBar->Append(mode_menu, "&Conversion Mode");
 318     menuBar->Append(help_menu, "&Help");
 319
 320     frame->SetMenuBar(menuBar);
 321     frame->textWindow = new wxTextCtrl(frame, -1, "", wxPoint(-1, -1), wxSize(-1, -1), wxTE_READONLY|wxTE_MULTILINE);
 322
 323     (*frame->textWindow) << "Welcome to Julian Smart's LaTeX to RTF converter.\n";
 324 //    ShowOptions();
 325
 326     HelpInstance = new wxHelpController();
 327     HelpInstance->Initialize("tex2rtf");
 328
 329     /*
 330      * Read macro/initialisation file
 331      *
 332      */
 333
 334     wxString path;
 335     if ((path = TexPathList.FindValidPath(MacroFile)) != "")
 336       ReadCustomMacros((char*) (const char*) path);
 337
 338     strcpy(buf, "In ");
 339
 340     if (winHelp && (convertMode == TEX_RTF))
 341       strcat(buf, "WinHelp RTF");
 342     else if (!winHelp && (convertMode == TEX_RTF))
 343       strcat(buf, "linear RTF");
 344     else if (convertMode == TEX_HTML) strcat(buf, "HTML");
 345     else if (convertMode == TEX_XLP) strcat(buf, "XLP");
 346       strcat(buf, " mode.");
 347     frame->SetStatusText(buf, 1);
 348
 349     frame->Show(TRUE);
 350     return TRUE;
 351   }
 352   else
 353 #endif // NO_GUI
 354   {
 355     /*
 356      * Read macro/initialisation file
 357      *
 358      */
 359
 360     wxString path;
 361     if ((path = TexPathList.FindValidPath(MacroFile)) != "")
 362       ReadCustomMacros((char*) (const char*) path);
 363
 364     Go();
 365     if (runTwice) Go();
 366 #ifdef NO_GUI
 367     return 0;
 368 #else
 369     return NULL;
 370 #endif
 371   }
 372
 373 #ifndef NO_GUI
 374   // Return the main frame window
 375   return TRUE;
 376 #else
 377   return FALSE;
 378 #endif
 379 }
 380
 381 int MyApp::OnExit()
 382 {
 383   wxNode *node = CustomMacroList.First();
 384   while (node)
 385   {
 386     CustomMacro *macro = (CustomMacro *)node->Data();
 387     delete macro;
 388     delete node;
 389     node = CustomMacroList.First();
 390   }
 391   MacroDefs.BeginFind();
 392   node = MacroDefs.Next();
 393   while (node)
 394   {
 395     TexMacroDef* def = (TexMacroDef*) node->Data();
 396     delete def;
 397     node = MacroDefs.Next();
 398   }
 399   MacroDefs.Clear();
 400 #ifdef __WXMSW__
 401   delete TheTex2RTFServer;
 402 #endif
 403   delete HelpInstance;
 404
 405   // TODO: this simulates zero-memory leaks!
 406   // Otherwise there are just too many...
 407 #ifndef __WXGTK__
 408   wxDebugContext::SetCheckpoint();
 409 #endif
 410
 411   return 0;
 412 }
 413
 414 void ShowOptions(void)
 415 {
 416     char buf[100];
 417     sprintf(buf, "Tex2RTF version %.2f", versionNo);
 418     OnInform(buf);
 419     OnInform("Usage: tex2rtf [input] [output] [switches]\n");
 420     OnInform("where valid switches are");
 421     OnInform("    -interactive");
 422     OnInform("    -bufsize <size in K>");
 423     OnInform("    -charset <pc | pca | ansi | mac> (default ansi)");
 424     OnInform("    -twice");
 425     OnInform("    -sync");
 426     OnInform("    -macros <filename>");
 427     OnInform("    -winhelp");
 428     OnInform("    -rtf");
 429     OnInform("    -html");
 430     OnInform("    -xlp\n");
 431 }
 432
 433 #ifndef NO_GUI
 434
 435 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 436     EVT_CLOSE(MyFrame::OnCloseWindow)
 437     EVT_MENU(TEX_QUIT, MyFrame::OnExit)
 438     EVT_MENU(TEX_GO, MyFrame::OnGo)
 439     EVT_MENU(TEX_SET_INPUT, MyFrame::OnSetInput)
 440     EVT_MENU(TEX_SET_OUTPUT, MyFrame::OnSetOutput)
 441     EVT_MENU(TEX_SAVE_FILE, MyFrame::OnSaveFile)
 442     EVT_MENU(TEX_VIEW_LATEX, MyFrame::OnViewLatex)
 443     EVT_MENU(TEX_VIEW_OUTPUT, MyFrame::OnViewOutput)
 444     EVT_MENU(TEX_VIEW_CUSTOM_MACROS, MyFrame::OnShowMacros)
 445     EVT_MENU(TEX_LOAD_CUSTOM_MACROS, MyFrame::OnLoadMacros)
 446     EVT_MENU(TEX_MODE_RTF, MyFrame::OnModeRTF)
 447     EVT_MENU(TEX_MODE_WINHELP, MyFrame::OnModeWinHelp)
 448     EVT_MENU(TEX_MODE_HTML, MyFrame::OnModeHTML)
 449     EVT_MENU(TEX_MODE_XLP, MyFrame::OnModeXLP)
 450     EVT_MENU(TEX_HELP, MyFrame::OnHelp)
 451     EVT_MENU(TEX_ABOUT, MyFrame::OnAbout)
 452 END_EVENT_TABLE()
 453
 454 // My frame constructor
 455 MyFrame::MyFrame(wxFrame *frame, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size):
 456   wxFrame(frame, id, title, pos, size)
 457 {}
 458
 459 void MyFrame::OnCloseWindow(wxCloseEvent& event)
 460 {
 461   if (!stopRunning && !OkToClose)
 462   {
 463     stopRunning = TRUE;
 464     runTwice = FALSE;
 465     return;
 466   }
 467   else if (OkToClose)
 468   {
 469 #ifdef __WXMSW__
 470     delete TheTex2RTFServer;
 471     wxDDECleanUp();
 472 #endif
 473     this->Destroy();
 474   }
 475 }
 476
 477 void MyFrame::OnExit(wxCommandEvent& event)
 478 {
 479     this->Destroy();
 480 }
 481
 482 void MyFrame::OnGo(wxCommandEvent& event)
 483 {
 484       menuBar->EnableTop(0, FALSE);
 485       menuBar->EnableTop(1, FALSE);
 486       menuBar->EnableTop(2, FALSE);
 487       menuBar->EnableTop(3, FALSE);
 488       textWindow->Clear();
 489       Tex2RTFYield(TRUE);
 490       Go();
 491
 492       if (runTwice)
 493       {
 494         Tex2RTFYield(TRUE);
 495         Go();
 496       }
 497       menuBar->EnableTop(0, TRUE);
 498       menuBar->EnableTop(1, TRUE);
 499       menuBar->EnableTop(2, TRUE);
 500       menuBar->EnableTop(3, TRUE);
 501 }
 502
 503 void MyFrame::OnSetInput(wxCommandEvent& event)
 504 {
 505       ChooseInputFile(TRUE);
 506 }
 507
 508 void MyFrame::OnSetOutput(wxCommandEvent& event)
 509 {
 510       ChooseOutputFile(TRUE);
 511 }
 512
 513 void MyFrame::OnSaveFile(wxCommandEvent& event)
 514 {
 515       wxString s = wxFileSelector("Save text to file", "", "", "txt", "*.txt");
 516       if (s != "")
 517       {
 518         textWindow->SaveFile(s);
 519         char buf[350];
 520         sprintf(buf, "Saved text to %s", (const char*) s);
 521         frame->SetStatusText(buf, 0);
 522       }
 523 }
 524
 525 void MyFrame::OnViewOutput(wxCommandEvent& event)
 526 {
 527       ChooseOutputFile();
 528       if (OutputFile && wxFileExists(OutputFile))
 529       {
 530         textWindow->LoadFile(OutputFile);
 531         char buf[300];
 532         wxString str(wxFileNameFromPath(OutputFile));
 533         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
 534         frame->SetTitle(buf);
 535       }
 536 }
 537
 538 void MyFrame::OnViewLatex(wxCommandEvent& event)
 539 {
 540       ChooseInputFile();
 541       if (InputFile && wxFileExists(InputFile))
 542       {
 543         textWindow->LoadFile(InputFile);
 544         char buf[300];
 545         wxString str(wxFileNameFromPath(OutputFile));
 546         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
 547         frame->SetTitle(buf);
 548       }
 549 }
 550
 551 void MyFrame::OnLoadMacros(wxCommandEvent& event)
 552 {
 553       textWindow->Clear();
 554       wxString s = wxFileSelector("Choose custom macro file", wxPathOnly(MacroFile), wxFileNameFromPath(MacroFile), "ini", "*.ini");
 555       if (s != "" && wxFileExists(s))
 556       {
 557         MacroFile = copystring(s);
 558         ReadCustomMacros((char*) (const char*) s);
 559         ShowCustomMacros();
 560       }
 561 }
 562
 563 void MyFrame::OnShowMacros(wxCommandEvent& event)
 564 {
 565       textWindow->Clear();
 566       Tex2RTFYield(TRUE);
 567       ShowCustomMacros();
 568 }
 569
 570 void MyFrame::OnModeRTF(wxCommandEvent& event)
 571 {
 572       convertMode = TEX_RTF;
 573       winHelp = FALSE;
 574       InputFile = NULL;
 575       OutputFile = NULL;
 576       SetStatusText("In linear RTF mode.", 1);
 577 }
 578
 579 void MyFrame::OnModeWinHelp(wxCommandEvent& event)
 580 {
 581       convertMode = TEX_RTF;
 582       winHelp = TRUE;
 583       InputFile = NULL;
 584       OutputFile = NULL;
 585       SetStatusText("In WinHelp RTF mode.", 1);
 586 }
 587
 588 void MyFrame::OnModeHTML(wxCommandEvent& event)
 589 {
 590       convertMode = TEX_HTML;
 591       winHelp = FALSE;
 592       InputFile = NULL;
 593       OutputFile = NULL;
 594       SetStatusText("In HTML mode.", 1);
 595 }
 596
 597 void MyFrame::OnModeXLP(wxCommandEvent& event)
 598 {
 599       convertMode = TEX_XLP;
 600       InputFile = NULL;
 601       OutputFile = NULL;
 602       SetStatusText("In XLP mode.", 1);
 603 }
 604
 605 void MyFrame::OnHelp(wxCommandEvent& event)
 606 {
 607       HelpInstance->LoadFile();
 608       HelpInstance->DisplayContents();
 609 }
 610
 611 void MyFrame::OnAbout(wxCommandEvent& event)
 612 {
 613       char buf[300];
 614 #ifdef __WIN32__
 615       char *platform = " (32-bit)";
 616 #else
 617 #ifdef __WXMSW__
 618       char *platform = " (16-bit)";
 619 #else
 620       char *platform = "";
 621 #endif
 622 #endif
 623       sprintf(buf, "Tex2RTF Version %.2f%s\nLaTeX to RTF, WinHelp, HTML and wxHelp Conversion\n\n(c) Julian Smart 1999", versionNo, platform);
 624       wxMessageBox(buf, "About Tex2RTF");
 625 }
 626
 627 void ChooseInputFile(bool force)
 628 {
 629   if (force || !InputFile)
 630   {
 631     wxString s = wxFileSelector("Choose LaTeX input file", wxPathOnly(InputFile), wxFileNameFromPath(InputFile), "tex", "*.tex");
 632     if (s != "")
 633     {
 634       // Different file, so clear index entries.
 635       ClearKeyWordTable();
 636       ResetContentsLevels(0);
 637       passNumber = 1;
 638       char buf[300];
 639       InputFile = copystring(s);
 640       wxString str = wxFileNameFromPath(InputFile);
 641       sprintf(buf, "Tex2RTF [%s]", (const char*) str);
 642       frame->SetTitle(buf);
 643       OutputFile = NULL;
 644     }
 645   }
 646 }
 647
 648 void ChooseOutputFile(bool force)
 649 {
 650   char extensionBuf[10];
 651   char wildBuf[10];
 652   strcpy(wildBuf, "*.");
 653   char *path = NULL;
 654   if (OutputFile)
 655     path = wxPathOnly(OutputFile);
 656   else if (InputFile)
 657     path = wxPathOnly(InputFile);
 658
 659   switch (convertMode)
 660   {
 661     case TEX_RTF:
 662     {
 663       strcpy(extensionBuf, "rtf");
 664       strcat(wildBuf, "rtf");
 665       break;
 666     }
 667     case TEX_XLP:
 668     {
 669       strcpy(extensionBuf, "xlp");
 670       strcat(wildBuf, "xlp");
 671       break;
 672     }
 673     case TEX_HTML:
 674     {
 675 #if defined(__WXMSW__) && defined(__WIN16__)
 676       strcpy(extensionBuf, "htm");
 677       strcat(wildBuf, "htm");
 678 #else
 679       strcpy(extensionBuf, "html");
 680       strcat(wildBuf, "html");
 681 #endif
 682       break;
 683     }
 684   }
 685   if (force || !OutputFile)
 686   {
 687     wxString s = wxFileSelector("Choose output file", path, wxFileNameFromPath(OutputFile),
 688                    extensionBuf, wildBuf);
 689     if (s != "")
 690       OutputFile = copystring(s);
 691   }
 692 }
 693 #endif
 694
 695 bool Go(void)
 696 {
 697 #ifndef NO_GUI
 698   ChooseInputFile();
 699   ChooseOutputFile();
 700 #endif
 701
 702   if (!InputFile || !OutputFile)
 703     return FALSE;
 704
 705 #ifndef NO_GUI
 706   if (isInteractive)
 707   {
 708     char buf[300];
 709     wxString str = wxFileNameFromPath(InputFile);
 710
 711     sprintf(buf, "Tex2RTF [%s]", (const char*) str);
 712     frame->SetTitle(buf);
 713   }
 714
 715   wxStartTimer();
 716 #endif
 717
 718   // Find extension-less filename
 719   strcpy(FileRoot, OutputFile);
 720   StripExtension(FileRoot);
 721
 722   if (truncateFilenames && convertMode == TEX_HTML)
 723   {
 724     // Truncate to five characters. This ensures that
 725     // we can generate DOS filenames such as thing999. But 1000 files
 726     // may not be enough, of course...
 727     char* sName = wxFileNameFromPath( FileRoot);  // this Julian's method is non-destructive reference
 728
 729     if(sName)
 730       if(strlen( sName) > 5)
 731         sName[5] = '\0';  // that should do!
 732   }
 733
 734   sprintf(ContentsName, "%s.con", FileRoot);
 735   sprintf(TmpContentsName, "%s.cn1", FileRoot);
 736   sprintf(TmpFrameContentsName, "%s.frc", FileRoot);
 737   sprintf(WinHelpContentsFileName, "%s.cnt", FileRoot);
 738   sprintf(RefName, "%s.ref", FileRoot);
 739
 740   TexPathList.EnsureFileAccessible(InputFile);
 741   if (!bulletFile)
 742   {
 743     wxString s = TexPathList.FindValidPath("bullet.bmp");
 744     if (s != "")
 745     {
 746       wxString str = wxFileNameFromPath(s);
 747       bulletFile = copystring(str);
 748     }
 749   }
 750
 751   if (wxFileExists(RefName))
 752     ReadTexReferences(RefName);
 753
 754   bool success = FALSE;
 755
 756   if (InputFile && OutputFile)
 757   {
 758     if (!FileExists(InputFile))
 759     {
 760       OnError("Cannot open input file!");
 761       TexCleanUp();
 762       return FALSE;
 763     }
 764 #ifndef NO_GUI
 765     if (isInteractive)
 766     {
 767       char buf[50];
 768       sprintf(buf, "Working, pass %d...", passNumber);
 769       frame->SetStatusText(buf);
 770     }
 771 #endif
 772     OkToClose = FALSE;
 773     OnInform("Reading LaTeX file...");
 774     TexLoadFile(InputFile);
 775
 776     switch (convertMode)
 777     {
 778       case TEX_RTF:
 779       {
 780         success = RTFGo();
 781         break;
 782       }
 783       case TEX_XLP:
 784       {
 785         success = XLPGo();
 786         break;
 787       }
 788       case TEX_HTML:
 789       {
 790         success = HTMLGo();
 791         break;
 792       }
 793     }
 794   }
 795   if (stopRunning)
 796   {
 797     OnInform("*** Aborted by user.");
 798     success = FALSE;
 799     stopRunning = FALSE;
 800   }
 801
 802   if (success)
 803   {
 804     WriteTexReferences(RefName);
 805     TexCleanUp();
 806     startedSections = FALSE;
 807
 808     char buf[100];
 809 #ifndef NO_GUI
 810     long tim = wxGetElapsedTime();
 811     sprintf(buf, "Finished in %ld seconds.", (long)(tim/1000.0));
 812     OnInform(buf);
 813     if (isInteractive)
 814     {
 815       sprintf(buf, "Done, %d %s.", passNumber, (passNumber > 1) ? "passes" : "pass");
 816       frame->SetStatusText(buf);
 817     }
 818 #else
 819     sprintf(buf, "Done, %d %s.", passNumber, (passNumber > 1) ? "passes" : "pass");
 820     OnInform(buf);
 821 #endif
 822     passNumber ++;
 823     OkToClose = TRUE;
 824     return TRUE;
 825   }
 826
 827   TexCleanUp();
 828   startedSections = FALSE;
 829
 830   OnInform("Sorry, unsuccessful.");
 831   OkToClose = TRUE;
 832   return FALSE;
 833 }
 834
 835 void OnError(char *msg)
 836 {
 837 #ifdef NO_GUI
 838   cerr << "Error: " << msg << "\n";
 839   cerr.flush();
 840 #else
 841   if (isInteractive)
 842     (*frame->textWindow) << "Error: " << msg << "\n";
 843   else
 844 #ifdef __UNIX__
 845   {
 846     cerr << "Error: " << msg << "\n";
 847     cerr.flush();
 848   }
 849 #endif
 850 #ifdef __WXMSW__
 851     wxError(msg);
 852 #endif
 853   Tex2RTFYield(TRUE);
 854 #endif // NO_GUI
 855 }
 856
 857 void OnInform(char *msg)
 858 {
 859 #ifdef NO_GUI
 860   cout << msg << "\n";
 861   cout.flush();
 862 #else
 863   if (isInteractive)
 864     (*frame->textWindow) << msg << "\n";
 865   else
 866 #ifdef __WXMSW__
 867   {
 868     cout << msg << "\n";
 869     cout.flush();
 870   }
 871 #endif
 872 #ifdef __WXMSW__
 873     {}
 874 #endif
 875   if (isInteractive)
 876   {
 877     Tex2RTFYield(TRUE);
 878   }
 879 #endif // NO_GUI
 880 }
 881
 882 void OnMacro(int macroId, int no_args, bool start)
 883 {
 884   switch (convertMode)
 885   {
 886     case TEX_RTF:
 887     {
 888       RTFOnMacro(macroId, no_args, start);
 889       break;
 890     }
 891     case TEX_XLP:
 892     {
 893       XLPOnMacro(macroId, no_args, start);
 894       break;
 895     }
 896     case TEX_HTML:
 897     {
 898       HTMLOnMacro(macroId, no_args, start);
 899       break;
 900     }
 901   }
 902 }
 903
 904 bool OnArgument(int macroId, int arg_no, bool start)
 905 {
 906   switch (convertMode)
 907   {
 908     case TEX_RTF:
 909     {
 910       return RTFOnArgument(macroId, arg_no, start);
 911       break;
 912     }
 913     case TEX_XLP:
 914     {
 915       return XLPOnArgument(macroId, arg_no, start);
 916       break;
 917     }
 918     case TEX_HTML:
 919     {
 920       return HTMLOnArgument(macroId, arg_no, start);
 921       break;
 922     }
 923   }
 924   return TRUE;
 925 }
 926
 927 /*
 928  * DDE Stuff
 929  */
 930 #if defined(__WXMSW__) && !defined(NO_GUI)
 931
 932 /*
 933  * Server
 934  */
 935
 936 wxConnectionBase *Tex2RTFServer::OnAcceptConnection(const wxString& topic)
 937 {
 938   if (topic == "TEX2RTF")
 939   {
 940     if (!ipc_buffer)
 941       ipc_buffer = new char[1000];
 942
 943     return new Tex2RTFConnection(ipc_buffer, 4000);
 944   }
 945   else
 946     return NULL;
 947 }
 948
 949  /*
 950   * Connection
 951   */
 952
 953 Tex2RTFConnection::Tex2RTFConnection(char *buf, int size):wxDDEConnection(buf, size)
 954 {
 955 }
 956
 957 Tex2RTFConnection::~Tex2RTFConnection(void)
 958 {
 959 }
 960
 961 bool SplitCommand(char *data, char *firstArg, char *secondArg)
 962 {
 963   firstArg[0] = 0;
 964   secondArg[0] = 0;
 965   int i = 0;
 966   int len = strlen(data);
 967   bool stop = FALSE;
 968   // Find first argument (command name)
 969   while (!stop)
 970   {
 971     if (data[i] == ' ' || data[i] == 0)
 972       stop = TRUE;
 973     else
 974     {
 975       firstArg[i] = data[i];
 976       i ++;
 977     }
 978   }
 979   firstArg[i] = 0;
 980   if (data[i] == ' ')
 981   {
 982     // Find second argument
 983     i ++;
 984     int j = 0;
 985     while (data[i] != 0)
 986     {
 987       secondArg[j] = data[i];
 988       i ++;
 989       j ++;
 990     }
 991     secondArg[j] = 0;
 992   }
 993   return TRUE;
 994 }
 995
 996 bool Tex2RTFConnection::OnExecute(const wxString& topic, char *data, int size, int format)
 997 {
 998   strcpy(Tex2RTFLastStatus, "OK");
 999
1000   char firstArg[50];
1001   char secondArg[300];
1002   if (SplitCommand(data, firstArg, secondArg))
1003   {
1004     bool hasArg = (strlen(secondArg) > 0);
1005     if (strcmp(firstArg, "INPUT") == 0 && hasArg)
1006     {
1007       if (InputFile) delete[] InputFile;
1008       InputFile = copystring(secondArg);
1009       if (frame)
1010       {
1011         char buf[100];
1012         wxString str = wxFileNameFromPath(InputFile);
1013         sprintf(buf, "Tex2RTF [%s]", (const char*) str);
1014         frame->SetTitle(buf);
1015       }
1016     }
1017     else if (strcmp(firstArg, "OUTPUT") == 0 && hasArg)
1018     {
1019       if (OutputFile) delete[] OutputFile;
1020       OutputFile = copystring(secondArg);
1021     }
1022     else if (strcmp(firstArg, "GO") == 0)
1023     {
1024       strcpy(Tex2RTFLastStatus, "WORKING");
1025       if (!Go())
1026         strcpy(Tex2RTFLastStatus, "CONVERSION ERROR");
1027       else
1028         strcpy(Tex2RTFLastStatus, "OK");
1029     }
1030     else if (strcmp(firstArg, "EXIT") == 0)
1031     {
1032       if (frame && frame->OnClose())
1033         delete frame;
1034     }
1035     else if (strcmp(firstArg, "MINIMIZE") == 0 || strcmp(firstArg, "ICONIZE") == 0)
1036     {
1037       if (frame)
1038         frame->Iconize(TRUE);
1039     }
1040     else if (strcmp(firstArg, "SHOW") == 0 || strcmp(firstArg, "RESTORE") == 0)
1041     {
1042       if (frame)
1043       {
1044         frame->Iconize(FALSE);
1045         frame->Show(TRUE);
1046       }
1047     }
1048     else
1049     {
1050       // Try for a setting
1051       strcpy(Tex2RTFLastStatus, RegisterSetting(firstArg, secondArg, FALSE));
1052 #ifndef NO_GUI
1053       if (frame && strcmp(firstArg, "conversionMode") == 0)
1054       {
1055         char buf[100];
1056         strcpy(buf, "In ");
1057
1058         if (winHelp && (convertMode == TEX_RTF))
1059           strcat(buf, "WinHelp RTF");
1060         else if (!winHelp && (convertMode == TEX_RTF))
1061           strcat(buf, "linear RTF");
1062         else if (convertMode == TEX_HTML) strcat(buf, "HTML");
1063         else if (convertMode == TEX_XLP) strcat(buf, "XLP");
1064           strcat(buf, " mode.");
1065         frame->SetStatusText(buf, 1);
1066       }
1067 #endif
1068     }
1069   }
1070   return TRUE;
1071 }
1072
1073 char *Tex2RTFConnection::OnRequest(const wxString& topic, const wxString& item, int *size, int format)
1074 {
1075   return Tex2RTFLastStatus;
1076 }
1077
1078 #endif
1079