util/liblogger/flex_ncurses.h

// copyright 2009 t. schneider tes@mit.edu
//
// this file is part of flex-ostream, a terminal display library
// that provides an ostream with both terminal display and file logging
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software.  If not, see <http://www.gnu.org/licenses/>.

#ifndef FlexNCurses20091110H
#define FlexNCurses20091110H

#include <vector>
#include <deque>
#include <string>

#include <boost/thread.hpp>

#include "term_color.h"
#include "goby/util/time.h"

class Group;

namespace goby
{
    namespace util
    {
        class FlexNCurses
        {
          public:


            FlexNCurses();
            ~FlexNCurses()
            {
                alive_ = false;
                cleanup();
            }


            void startup();
            void add_win(const Group* title);



            void insert(boost::posix_time::ptime t, const std::string& s, Group* g);
            

            size_t panel_from_group(Group* g);
            void recalculate_win();
            void cleanup();
            void alive(bool alive);
            


            void run_input();
    
          private:
            class Panel;
            void putline(const std::string &s, unsigned scrn, bool refresh = true);

            void putlines(unsigned scrn,
                          const std::multimap<boost::posix_time::ptime, std::string>::const_iterator& alpha,
                          const std::multimap<boost::posix_time::ptime, std::string>::const_iterator& omega,
                          bool refresh = true);
    
 
            void update_size();
            long color2attr_t(Colors::Color c);
            size_t find_containing_window(int y, int x);
    
            // void* is WINDOW*
            bool in_window(void* p, int y, int x);
    
            void write_head_title(size_t i);
            void deselect_all();    
            void select_all();
            void select(size_t gt);
            void home();
            void end();

            size_t down() { return down(find_first_selected()); }
            size_t up() { return up(find_first_selected()); }
            size_t left() { return left(find_first_selected()); }
            size_t right() { return right(find_first_selected()); }        
            size_t down(size_t curr);
            size_t up(size_t curr);
            size_t left(size_t curr);
            size_t right(size_t curr);
            size_t find_first_selected();
            void shift(size_t next);

            bool last_in_col(size_t val);
            bool first_in_col(size_t val);
    
            void move_up(); 
            void move_down();
            void move_right();
            void move_left();

            void combine();
            void uncombine_all();
            void uncombine(size_t i); 
            void uncombine_selected(); 
            int lines_from_beg(int l, size_t i);
  
            void scroll_up(); 
            void scroll_down();
            void page_up(); 
            void page_down();
            void scroll_end(); 
            void scroll_home();
    
            void winlock(); 
            void winunlock();

            void grow_all();
            void shrink_all();
            void grow(int i); 
            void shrink(int i);

            void restore_order();
    
    
            void toggle_minimized(int i);
            void redraw_lines(int j, int offset = -1 );
    
            std::multimap<boost::posix_time::ptime, std::string> get_history(size_t i, int how_much = -1);
            size_t get_history_size(size_t i);
    
    
            template<typename T>
                T min(const T& a, const T& b)
            { return (a < b ? a : b); }    

            template<typename T>
                T max(const T& a, const T& b)
            { return (a > b ? a : b); }    
    
          private:
            int xmax_;
            int ymax_;

            int xwinN_;
            int ywinN_;
    
            int last_select_x_;
            int last_select_y_;
    
            // void* is WINDOW*
            std::vector<void* > vert_windows_;
            // bottom of the column (indexed by column)
            std::vector<void* > col_end_windows_;
            void* foot_window_;

            bool is_locked_;
            int locked_panel_;
    
            class Panel
            {
              public:
              Panel(const Group* group = 0)
                  : group_(group),
                    window_(0),
                    head_window_(0),
                    minimized_(false),
                    selected_(false),
                    locked_(false),
                    col_(1),
                    lines_from_beg_(0),
                    original_order_(0),
                    max_hist_(20000)
                    {}

                void window(void* v) { window_ = v; }
                void head_window(void* v) { head_window_ = v; }
                void group(const Group* g) { group_ = g; }
                // returns number of lines to grow/shrink
                void set_minimized(bool b) { minimized_ = b; } 
                int minimized(bool b);        
                int toggle_minimized() { return minimized(minimized() ^ true); }
                void selected(bool b) { selected_ = b; }
                void ywidth(int i) { ywidth_ = i; }
                int lines_from_beg(int i);
                void grow() { ++ywidth_; }
                void locked(bool b)  { locked_ = b; }
                bool shrink()
                {
                    if(ywidth_ == HEAD_Y)
                        return false;
                    else
                    {
                        --ywidth_;
                        return true;
                    }
                }        
                void col(int i) { col_ = i; }
                void original_order(int i) { original_order_ = i; }
                void add_combined(size_t i) { combined_.insert(i); }
                void clear_combined() { combined_.clear(); }        
        
                void* window() const { return window_; }
                void* head_window() const { return head_window_; }
                const Group* group() const { return group_; }
                bool minimized() const { return minimized_; }
                bool selected() const { return selected_; }
                int ywidth() const { return ywidth_; }
                int col() const { return col_; }
                bool locked() const { return locked_; }
                int lines_from_beg() const { return lines_from_beg_; }        
                int original_order() const { return original_order_; }
                std::multimap<boost::posix_time::ptime, std::string>& history() { return history_; }
                unsigned max_hist() const { return max_hist_; }
                const std::set<size_t>& combined() const { return combined_; }
        
              private:
                const Group* group_;
                void* window_;
                void* head_window_;
                bool minimized_;
                bool selected_;
                bool locked_;
                int ywidth_;
                int unminimized_ywidth_;
                int col_;
                int lines_from_beg_;
                int original_order_;
                unsigned max_hist_;
                std::multimap<boost::posix_time::ptime, std::string> history_;
                std::set<size_t> combined_;
            };    

            std::vector<Panel> panels_;
            std::set<size_t> unique_panels_;
    
            // extra lines if everyone is minimized
            // indexed by column
            std::vector<int> line_buffer_;
    
            bool alive_;
    
            // ideal number of characters per line
            enum { CHARS_PER_LINE = 85 };

            enum { HEAD_Y = 1 };
            enum { FOOTER_Y = 3 }; 
    
        };
    }
}


#endif