editor.cxx

Go to the documentation of this file.

// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.



//@File

#include <cxxtls/viewermanager.h>
#include <cxxtls/file.h>
#include <list>
#include <set>
#include <cxxtls/directoryviewer.h>
#include <cxxtls/textviewer.h>
#include <cxxtls/keyviewer.h>
#include <texteditor.hxx>
#include <cxxtls/ftpviewer.h>
#include <cxxtls/csvviewer.h>
#include <cxxtls/scripttableviewer.h>
#include <cxxtls/options.h>
#include <cxxtls/symbolviewer.h>

#include <stdlib.h>

using namespace cxxtls;

extern char const *editversion;  // see makefile

typedef CursorWindow::input_event input_event;

using namespace std;

Viewer* read_only_edit(ViewerManager*vm, std::string &fullname)
{
  TextEditor* rv = static_cast<TextEditor*>(TextEditor::app(vm,fullname));

  if(rv)
  {
    rv->set_read_only();
  }

  return rv;

}



int main(int argc, char **argv, char **environ)
{

  static char const *allowed_arguments=
  "-ftp," // use compiler concatenation to implement arguments here
  "-h,"
  "-help,"
  "-s,"
  "-l:"
  ;

  ProgramOptions::global_options_ = new ProgramOptions(allowed_arguments,
                                                       argc,
                                                       argv,
                                                       environ);

  ProgramOptions &options = *ProgramOptions::global_options_;

  ViewerManager vm; 

  vm.executable_version_ = editversion;
  vm.executable_name_    = options.argv[0]; // guaranteed to exist

  vm.open();  // need to open the window so that sizes of viewports
              // can be calculated.  This must be done AFTER the program
              // options are parsed because of the potential of the ProgramOptions
              // constructor to call exit().  If the window is open when that happens
              // the terminal characteristics will get messed up.
        
  vm.add_app(DirectoryViewer::app, DirectoryViewer::app_name);
  vm.set_directory_app(DirectoryViewer::app);

  vm.add_app(TextViewer::app, TextViewer::app_name);
  // vm.add_viewer_app(TextViewer::app, "");  // handles all files extensions
  vm.add_viewer_app(read_only_edit, "");  // handles all files extensions

  vm.add_app(TextEditor::app, TextEditor::app_name);
  vm.add_editor_app(TextEditor::app, "");  // handles all files extensions

  vm.add_app(CsvViewer::app, "CsvViewer");
  vm.add_editor_app(CsvViewer::app, ".csv");  

  vm.add_app(CsvViewer::app, "TsvViewer");
  vm.add_editor_app(CsvViewer::app, ".tsv");  

  vm.add_app(KeyViewer::app, KeyViewer::app_name);

  vm.add_app(FTPviewer::app, FTPviewer::app_name);

  vm.add_app(ScriptTableViewer::app, "TableCommander");
  vm.add_editor_app(ScriptTableViewer::app, ".stvsh");  

  vm.add_app(SymbolViewer::app, "SymbolViewer");
  vm.add_viewer_app(SymbolViewer::app, ".tagpp");  // cpptagdb.exe generated databases

  vm.add_viewer_app(SymbolViewer::app, ".cpptagdb");  // The symbol viewer knows that if the file name 
                                                      // extension is .cpptagdb, then it should 
                                                      // use cpptagdb.exe to read the file, minus the
                                                      // trailing .cpptagdb, using popen()

  // vm.add_editor_app(SymbolViewer::app, ".tagpp");  // you can't really EDIT this kind of file


  if(options.option("-h") || options.option("-help"))
  {
    vm.close();

    FileName me;

    if(options.argv.size() >= 1)
      me = options.argv[0];

    string prog = me.basename();


    cout << "This program supports the following command line options" << endl
         << endl
         << "  " << allowed_arguments << endl
         << endl
         ;
    cout
         << "Options have the following meaning and parameters:" << endl
         << "  (none)    -- list the current directory" << endl
         << "  filedir   -- edit the named file or directory" << endl
         << "  -s file   -- view the named file" << endl
         << "  -l n file -- edit fil and position to line n" <<endl
         << endl
         << "  -ftp [h] [u] [p] [d] -- start ftp session" << endl
         << "     host, user, password, and local directory are optional" << endl
         ;
    exit(1);
  }
  else
  if(options.option("-ftp"))
  {
    string path;

    if(options.argv.size() > 1)
    {
      // ie there were non-option arguments, treat them as parms to the ftp protocol

      for(size_t i=1; i < options.argv.size(); ++i)
      {
         path += options.argv[i];
         path += ' ';
      }

    }

    Viewer* ftpviewer = FTPviewer::app(&vm, path);

    if(ftpviewer)
    {
      vm.add(ftpviewer, path);
    }
    else
    {
      vm.close();
      exit(1);
    }

  }
  else
  if(options.argv.size() == 2)
  {
    // one name specified

    FileName pathname(options.argv[1]);

    pathname = pathname.expand_tildes();

    pathname.convert_to_absolute_path();

    if(pathname.is_dir())
    {
      pathname.convertToDirectorySearchPattern();
    }


    Viewer* editor;

    if(options.option("-s"))
      editor = vm.open(pathname);
    else
      editor = vm.edit(pathname);

    if(editor == 0)
    {
      vm.close();
      cout << "Error, couldn't find an editor for '" << pathname << "'" << endl;
      exit(1);
    }

    int line=1;

    if(options.option("-l"))
    {
      ProgramOptions::value_iterator first = options.option("-l").begin();

      sscanf(first->c_str(), "%d", &line);

      editor->set_row_col_hint(line-1,0);
    }


    vm.add(editor, pathname);

  }
  else
  if(options.argv.size() > 2)
  {
    for(size_t i = 1; i < options.argv.size(); ++i)
    {
      FileName pathname(options.argv[i]);
      
      pathname = pathname.expand_tildes();

      pathname.convert_to_absolute_path();
      
      if(pathname.is_dir())
      {
        pathname.convertToDirectorySearchPattern();
      }
      
      Viewer* editor;
      
      if(options.option("-s"))
        editor = vm.open(pathname);
      else
        editor = vm.edit(pathname);
      
      if(editor == 0)
      {
        vm.close();
        cout << "Error, couldn't find an editor for '" << pathname << "'" << endl;
        exit(1);
      }
      
      
      if(options.option("-l"))
      {
        int line=1;

        sscanf(options.option("-l").begin()->c_str(), "%d", &line);
      
        editor->set_row_col_hint(line-1,0);
      }
      
      vm.add(editor, pathname);

    }
  }
  else
  {
    FileName curdir(".");
    curdir.convert_to_absolute_path();
    curdir.convertToDirectorySearchPattern();
    vm.add(vm.edit(curdir), curdir);
  }

        
  vm.run();


  return 0;
}