viewermanager.h

Go to the documentation of this file.

#ifndef viewermanager_h_included
#define viewermanager_h_included

//
// 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.

//

#include <cxxtls/viewer.h>
#include <utility>
#include <cxxtls/sequence_map.h>
#include <cxxtls/file.h>
#include <cxxtls/mru.h>

namespace cxxtls
{

class ViewerSelector;
class appChooser;
class EtagsDB;
namespace CppTagDB { class Info; }

class ProgramOptions;  // for use by the default_etags_path() method

class ViewerManager
//
//
{
public:

  static int normal_att;        
  static int active_title_att;  
  static int inactive_title_att;
  static int active_mark_att;   
  static int inactive_mark_att; 
  static int bottom_att;        
  static int highlighted_att;   

  static std::list<std::string> key_bindings_doc;  



  friend class ViewerSelector; 
  friend class appChooser;     


  typedef CursorWindow::viewport            viewport;        



  typedef CursorWindow::input_event         input_event;     
  typedef std::auto_ptr<viewport>           vp_handle;       
  typedef CursorWindow::row_col             row_col;         
  typedef std::pair<Viewer*,std::string>    vpentry;         
  typedef viewport::repaint_handler         repaint_handler; 

  typedef Viewer* (*application)(ViewerManager*vm, std::string &fullname);

  typedef std::pair<application,std::string>  appentry;


  CursorWindow* window() { return &cw_; } 

  struct FileLocation
  {
     std::string filename_;
     int         lineNumber_;

     FileLocation(std::string const &file, int line)
     : filename_(file)
     , lineNumber_(line)
     {
     }

     FileLocation()
     : lineNumber_(0)
     {
     }


  };

  typedef std::list<FileLocation> FileLocations;



private:

  std::string            tool_dir_;  

  CursorWindow           cw_;        

  std::vector<viewport*> viewports_; 




  std::vector<vpentry>   viewers_;   







  MRU<std::string>       order_;     

  size_t                 active_viewport_;

  void setup_key_bindings();         

  void dispatch_event(input_event const &e);
                                
  void handle_master_command(int cmd); 

  std::auto_ptr<Viewer>       vs_;     

  std::vector<appentry>       apps_; 

  size_t override_active_viewport_;  


  typedef std::pair<application, std::string> opener_map_entry; 

  std::list<opener_map_entry> openers_;  

                                        
  std::list<opener_map_entry> editors_;  

                                        
                                        
  application                 dir_opener_;  

  std::string                 exit_dir_; 


  void recordExitDir() const;  


  FileLocations fileLocations_; 

public:

  void findMatchingViewers(FileName namePattern, std::list<std::pair<Viewer*, FileName> > &viewers);


  ViewerManager(); 
 ~ViewerManager(); 


  FileName find_file_in_standard_locations(FileName const &fragment, FileName const &directory);

  bool popFileLocation(FileLocation &output)
  {
     if(fileLocations_.empty())
        return false;

     output = fileLocations_.front();
     fileLocations_.pop_front();

     return true;
  }

  template<class Container>
  void setFileLocations(Container const &c)
  {
     typename Container::const_iterator first = c.begin(), last = c.end();

     fileLocations_.clear();

     while(first != last)
     {
        fileLocations_.push_back(*first++);
        
     }
  }

  void add_app(application a, std::string const &s)
  {
    apps_.push_back(appentry(a,s));
  }

  void vsplit(Viewer*, std::string fullname);

  void hsplit(Viewer*, std::string fullname);

  void add(Viewer*, std::string fullname);

  bool activate(Viewer* v);

  bool is_visible(Viewer* v);

  void unify(); 


                
  void vs();    



  void open(); 


        
  void close(); 

                
  void exit();   
                
  void run();   

  enum master_commands   
  {                      

     vertical_split,     
     horizontal_split,   
     unsplit,            
     next,               
     selector,           
     die,                
     die_and_jump,       


     new_application,    
     new_viewer,         
     new_editor,         
     display_help,       
     interactive_shell,  
     last_command
  };

  typedef Sequence_Map<int,int> master_key_map;

  master_key_map  master_keys_;

  Viewer* active_viewer()
  {
    size_t viewport_no = active_viewport_;

    if(override_active_viewport_ < viewports_.size())
      viewport_no = override_active_viewport_;

    if(viewports_.size())
      return static_cast<Viewer*>( viewports_[viewport_no]->get_repaint_handler() );

    return 0;
  }

  viewport* active_viewport()
  {
    size_t viewport_no = active_viewport_;

    if(override_active_viewport_ < viewports_.size())
      viewport_no = override_active_viewport_;

    return viewports_[viewport_no];
  }


  Viewer* find_viewer(std::string const& viewername);

  Viewer* most_recent_viewer();

  std::string find_viewer_name(Viewer *vp);

  size_t find_viewport_index(std::string const &viewername);  








  void help();

  void help_helper( std::list<std::string>  &  help_text);

  Viewer* open(std::string const &fullname);

  Viewer* edit(std::string const &fullname);

  void set_directory_app(application);

  void add_viewer_app(application, std::string filename_extension);

  void add_editor_app(application, std::string filename_extension);

  Viewer::paste_buffer_type  paste_buffer_;

  void popup_new_viewer(bool edit=false);

  void splitscreen_new_editor(bool horizontal=false);

  std::string active_directory() const;

  void handle_die_request();

  std::string executable_version_;

  std::string executable_name_;

  static std::string default_etags_path(std::string &pathlist, char const *file="TAGS");

  EtagsDB* default_etags_db();

  CppTagDB::Info* default_cpptags_db();


  int   find_files(std::string operand, std::list<std::string> *result);

};
} // namespace cxxtls
#endif