cursorwindow.h

Go to the documentation of this file.

#ifndef CURSOR_WINDOW_H_INCLUDED
#define CURSOR_WINDOW_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 <string>
#include <vector>
#include <string.h>
#include <list>
#include <map>
#include <cxxtls/streamable.h>
#include <memory>

namespace cxxtls
{

class Viewer; // see viewer.h

class CursorWindow
  //
  //
: public Ostreamable<CursorWindow>
{
    class   Window;
    friend class SaveRestoreActiveWindow;

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 int dialog_normal_att; 
    static int dialog_title_att;  

    class    viewport;

    friend class viewport;

    struct row_col
      //
      //
    {
      int row_;
      int col_;

      row_col(int row, int col) 
      : row_(row),
        col_(col)
      {
      }

      row_col()                 
      : row_(0),
        col_(0)
      {
      }

      bool operator==(row_col const &r)  
      {
        return row_ == r.row_ && col_ == r.col_;
      }

    };

    char const *error() const;
      

    void set_error(char const *);
      

    void clear_error() { set_error(0); }
      

    CursorWindow();
      

   ~CursorWindow();
      

    bool open();


    void close();

    void resize_viewports(row_col const &old_size, row_col const &new_size);

    void repaint_all();

    struct input_event
      
    {
      enum type_constants 
      {
        NoKey=0,          
        DataKey,          
        FunctionKey,      
        ResizeKey,        


        ForceExitKey,     
        MouseEvent
      };

      int type_;   
      int value_;  




      int row_;    
      int col_;    

      enum buttons
      {
        left  = 1,
        right = 2,
        middle= 4 // powers of two...
      };

      input_event(int type, int value, int row=0, int col=0)   
      : type_(type),
        value_(value),
        row_(row),
        col_(col)
      {
      }

      input_event()                      
      : type_(NoKey),
        value_(0),
        row_(0),
        col_(0)
      {
      }

    };

    input_event read_input();
      


    row_col curpos() const;

    void set_curpos(int row, int col)
    {
      set_curpos( row_col(row, col) );
    }

    void set_curpos(row_col rc);

    row_col size() const;


    void beep();

    void write(char const *, size_t length);


    void write(char const *s)
    {
       write(s, strlen(s));
    }

    void write(std::string const &s, size_t length=1000000)
      //
    {
      size_t actual_length = s.size();

      write(s.data(), actual_length < length ? actual_length : length );
    }

    void write(long c, int length=1);



    void fill_to_eol(char c=' ');

    void box(int width, 
             int height, 
             bool filled,
             char const *title_string, 
             unsigned length
            );

    void box(int width, int height, bool filled, char const *title=0)
    {
      box(width, height, filled, title, title ? strlen(title): 0);
    }

    void box(int width, int height, bool filled, std::string title)
      //
    {
      box(width, height, filled, title.data(), title.size());
    }


    void fill_to_eos(char c=' ');

    enum text_attributes
      //
    {
      normal,       
      reversed,     
      underlined,   
      blinking,     
      bold,         
      reverse_ul,   
      reverse_bold, 
      rev_ul_bold,  
      bold_ul       
    };

    int text_attribute() const;

    void set_text_attribute(int);


    enum key_names 
    {
       first_function_key=0x100,
       //< first the unshifted function keys
       key_f1,  key_f2,  key_f3, key_f4, key_f5, key_f6, key_f7, key_f8, key_f9, key_f10,
       key_f11, key_f12,
       key_up, key_down, key_left, key_right, key_home, key_end, key_prior, key_next,
       key_ic,  //< Insert key
       key_dc,  //< Delete key
       key_bs,  //< Backspace key
       key_btab,
       key_sf1,  key_sf2,  key_sf3, key_sf4, key_sf5, key_sf6, key_sf7, key_sf8, key_sf9, key_sf10,
       key_sf11, key_sf12,
       key_sup, key_sdown, key_sleft, key_sright, key_shome, key_send, key_sprior, key_snext,
       key_sic, key_sdc,

       last_function_key  

    };

    static std::string key_name(int keyvalue);

    enum edit_function_names
    {
      func_unknown, 
      func_up, func_down, func_left, func_right,
      func_ic,      
      func_dc,      
      func_home,    
      func_end,     
      func_prior,   
      func_next,    
      func_dc_prev, 
      func_tab,     
      func_btab,    
      func_top,     
      func_bottom,  
      func_esc,     
      func_enter,   
      func_data,    
      func_clreol,  
      func_nextwd,  
      func_prevwd,  
      func_upword,  
      func_dnword,  
      func_undo,    
      func_find,    
      func_findnxt, 
      func_findprv, 
      func_repl,    
      func_replnext,
      func_help,    
      func_mark,    
      func_dl,      
      func_db,      
      func_cb,      
      func_wb,      
      func_paste,   
      func_goto,    
      func_matching,
      func_dw,      
      func_join,    
      func_insline, 
      func_to_edit, 
      func_reread,  
      func_switch,  
      func_insfile, 

      user_function_0=0x100  


    };

    static std::string        func_name(int funcvalue);

    static std::map<int,int>  func;


    static std::string word;



    struct resize_handler
    {
      virtual void operator() (CursorWindow*)=0;
      virtual ~resize_handler();
    };

    void set_resize_handler(resize_handler *);


    class viewport
      //
      //
      : public Ostreamable<viewport>
    {
    public:

      struct repaint_handler
       //

      {
        virtual void operator() ( viewport * vp, int cmd ) = 0;
        virtual ~repaint_handler();
        
        enum cmd_constant
        {
          activate,     
          deactivate,   
          resize        
        };
      };

      enum position
      {
         tiled,   

         floating 
      };

      viewport(CursorWindow*, repaint_handler*, position p=tiled);
     ~viewport();                                


      viewport(viewport const &);                



                                                
     private:

      viewport &operator= (viewport const &r);   
                                        
      public:

      void set_repaint_handler(repaint_handler *r);

      repaint_handler* get_repaint_handler();


      std::auto_ptr<viewport> vsplit(repaint_handler*);

        
      std::auto_ptr<viewport> hsplit(repaint_handler*);


      row_col curpos() const;


      void set_curpos(int row, int col)
        //
      {
        set_curpos( row_col(row, col) );
      }

      void set_curpos(row_col rc);
        
      void restore_curpos();

      row_col size() const;

        
      row_col origin() const;


      void beep();
        
      template<class Iterator>
      void write(Iterator first, Iterator last) 
      {
        while(first != last) write(*first++);
      }
        
      void write(char const *, size_t length);


      void write(char const *s)
      {
         write(s, strlen(s));
      }

      void write(std::string const &s, size_t length=1000000)
        //
      {
        size_t actual_length = s.size();
        
        write(s.data(), actual_length < length ? actual_length : length );
      }

      void write(long c, int length=1);


      void fill_to_eol(char c=' ');

      void box(int width, 
               int height, 
               bool filled,
               char const *title_string, 
               unsigned length
              );
      
      void box(int width, int height, bool filled, char const *title=0)

        








      {
        box(width, height, filled, title, title ? strlen(title): 0);
      }
      
      void box(int width, int height, bool filled, std::string title)
        //
      {
        box(width, height, filled, title.data(), title.size());
      }

      void fill_to_eos(char c=' ');
        //

      int text_attribute() const;
        //

      void set_text_attribute(int);


      void move(row_col where, row_col size);
        
      void activate();

      void refresh();
        //


      struct port;

      port* port_;  


      bool  owned_; 




      friend class  CursorWindow;


    public:

      viewport(port*);


      CursorWindow* window();

      void ostreamable_helper(char c)
      {
        write(&c, 1);
      }

    }; // end of class viewport

    std::auto_ptr<viewport> new_viewport(viewport::repaint_handler*,
                                viewport::position p = viewport::tiled);
  

    void needs_resized();
    


    void refresh();
    

    class Dialog
      //
    : public viewport::repaint_handler
    {
    public:
      class Impl;
      friend class Impl;

    private:

      Impl *impl_;

    public:

      Dialog(std::string title);
       
        
        
     ~Dialog();
       

      void operator() ( viewport * vp, int cmd );
        

      bool popup(CursorWindow*);

        
      void set_completion_directory(std::string const &s);

        
      std::string const &completion_directory() const;


      void set_first_input_field(std::string const &s);


      class Element
      {
      protected:

        Dialog*     dialog_; //< when you append a dialog element to a dialog
                             //  this field gets set by the Dialog::operator+= method.
                        
        friend class Dialog;
        
      public:

        std::string name_;
        std::string label_;
        std::string value_;
        int         input_width_;

        Element(std::string const& name, std::string const &label, int width=0)
        : name_(name),
          label_(label),
          input_width_(width)
        {
        }
        

        virtual ~Element() {}

        virtual void draw_input_area(viewport *v, bool highlighted) = 0;


        virtual void handle_key(viewport *v, int key) = 0;
          


      };

      typedef std::list<Element*>  element_list_t;
      typedef element_list_t::iterator iterator;

    public:

      Dialog& operator += (Element *e);

      iterator begin();
      iterator end();

      class Ok
        //
        //
      : public Element
      {
      public:

        Ok(std::string const &name, std::string const &label)
        : Element(name, label, 4)
        {
        }

        void draw_input_area(viewport *v, bool highlighted);

        void handle_key(viewport*v, int key);
      };

      class String
        //
        //
      : public Element
      {
        int col_;     


        int offset_;  


        int width_;   

        int input_;   



      protected:

        bool password_;  

      public:

        String(std::string const &name,
               std::string const &label,
               std::string const &default_value,
               int                input_width)
        : Element(name, label, input_width),
          col_(0),
          offset_(0),
          width_(input_width),
          input_(0),
          password_(false)
        {
        
          value_ = default_value;
        }

        void draw_input_area(viewport *v, bool highlighted);

        void handle_key(viewport*v, int key);
        
        bool compute_actual_width(viewport *v);
        
        void handle_paging(viewport *v);

        void setColumn(int col);

      };

      class Password
       //
      : public String
      {
      public:

        Password(std::string const &name,
                 std::string const &label,
                 std::string const &default_value,
                 int                input_width)
        : String(name, label, default_value, input_width)
        {
          password_ = true;
        }
      };

      std::string element_value(std::string const &name);
    };

    class Selection
      //
    : public viewport::repaint_handler
    {
    public:

      class   Impl;
      typedef std::list<std::string> rep_type;  

    private:

      Impl* impl_;                              


    public:

      rep_type rep_;                            





      std::string selection_;                   





      Selection(std::string title);
        
        
     ~Selection();

      void operator() ( viewport * vp, int cmd );


      bool popup(CursorWindow*);

        //
        
      void operator+= (std::string const &s)
      {

        //
        rep_.push_back(s);
      }
        
    };


    class Message
      //
    : public viewport::repaint_handler
    {
    public:

      class   Impl;

      typedef std::list<std::string> rep_type;  

    private:

      Impl* impl_;                              


    public:

      rep_type rep_;                            





      Message(std::string title);
        
     ~Message();

      void operator() ( viewport * vp, int cmd );
  

      void popup(CursorWindow*);
  
        //
        
      void operator+= (std::string const &s)
      {
  
  
        rep_.push_back(s);
      }
        
    };


    class FileSelector
    : public viewport::repaint_handler
    {

    public:

       FileSelector(std::string const &title,
                    std::string const &filenamePattern,
                    std::string const &startFileName
                   );
      
      void operator() ( viewport * vp, int cmd );

      std::string popup(CursorWindow*window, Viewer *parent);

    private:

        std::string title_;
        std::string searchPattern_;
        std::string searchDir_;             // populated by readFileInfo
        std::string startFile_;

        std::vector<std::string> rowText_;  // names and perhaps other info
        size_t maxNameWidth_;               // longest string in rowText_;

        int row_;               // screen relative position of dialog (top row)
        int col_;               // left coloumn
        int dialogHeight_;      // in rows
        int dialogWidth_;       // in cols


        int displayAreaRow_;    // top of display area
        int displayAreaCol_;    // left of display area
        int displayAreaHeight_;
        int displayAreaWidth_;  

        int inputIndex_;     // into rowText_
        int inputTopIndex_;  // index into rowText_ of top item displayed in the display area

        bool noRepaint_;     // true only in minute instants when popup is still running
                             // but we want to ignore calls to operator()()


        void adaptToWindow(viewport *); // recalculate display coordinates and active
                                        // window regions based on actual window sizes

        void paintDialogBackground(viewport *); // paint the dialog region in the appropriate colors

        void readFileInfo();

        std::string handleInput(CursorWindow *w, Viewer *parent);
                                              
        void paintRow(CursorWindow *w, int displayAreaRow);  // repaint current specified row

        void eraseMe(CursorWindow *w);   // remove this dialog from the screen


    };

    // bogus do not use!
    static std::string select_file(std::string const &title,
                                   std::string const &dir_file_pattern,
                                   CursorWindow *w
                                  );

    void ostreamable_helper(char c)
      //
      //
    {
      write(&c, 1);
    }




    int get_viewports(std::list<viewport> *viewports);


private:

                        
    Window * window_; 

    void destroy_viewport(viewport*);


}; // CursorWindow 
} // namespace cxxtls

#endif