pager.h

// pager.h       -*-c++-*-
//
//  Copyright 2000-2004 Daniel Burrows
//
//  A widget which acts as a text pager.

#ifndef PAGER_H
#define PAGER_H

#include "widget.h"

#include <string>
#include <vector>

class keybindings;

namespace cwidget
{
  namespace widgets
  {
    class pager : public widget
    {
    public:
      typedef std::vector<std::wstring>::size_type line_count;
      typedef int col_count;
    private:
      std::vector<std::wstring> lines;

      line_count first_line;

      col_count first_column;

      col_count text_width;

      std::wstring last_search;

      void layout_me();

      void search_omnidirectional_for(const std::wstring &s, bool forward);

    protected:
      pager(const char *text, int len, const char *encoding = NULL);
      pager(const std::string &s, const char *encoding = NULL);
      pager(const std::wstring &s);

    public:
      static util::ref_ptr<pager>
      create(const char *text, int len, const char *encoding = NULL)
      {
        util::ref_ptr<pager> rval(new pager(text, len, encoding));
        rval->decref();
        return rval;
      }

      static util::ref_ptr<pager>
      create(const std::string &s, const char *encoding = NULL)
      {
        util::ref_ptr<pager> rval(new pager(s, encoding));
        rval->decref();
        return rval;
      }

      static util::ref_ptr<pager>
      create (const std::wstring &s)
      {
        util::ref_ptr<pager> rval(new pager(s));

        rval->decref();

        return rval;
      }

      virtual ~pager();

      virtual void set_text(const char *text,
                            std::string::size_type len,
                            const char *encoding=NULL);

      virtual void set_text(const std::string &s, const char *encoding=NULL);

      virtual void set_text(const std::wstring &s);

      void scroll_up(line_count nlines);

      void scroll_down(line_count nlines);

      void scroll_right(col_count ncols);

      void scroll_left(col_count ncols);

      void scroll_top();

      void scroll_bottom();

      void scroll_page(bool dir);

      void search_for(const std::wstring &s)
      {
        search_omnidirectional_for(s, true);
      }

      void search_back_for(const std::wstring &s)
      {
        search_omnidirectional_for(s, false);
      }

      std::wstring get_last_search() {return last_search;}

      line_count get_first_line() {return first_line;}
      line_count get_num_lines() {return lines.size();}
      col_count get_first_column() {return first_column;}
      col_count get_num_columns() {return text_width;}

      void do_line_signal();

      void do_column_signal();

      virtual bool handle_key(const config::key &k);
      virtual bool focus_me() {return true;}
      virtual void paint(const style &st);

      int width_request();
      int height_request(int w);
      bool get_cursorvisible() {return true;}
      point get_cursorloc() {return point(0,0);}

      sigc::signal2<void, int, int> line_changed;

      sigc::signal2<void, int, int> column_changed;

      static config::keybindings *bindings;
      static void init_bindings();
    };

    class file_pager:public pager
    {
    protected:
      file_pager();
      file_pager(const std::string &filename, const char *encoding = NULL);
      file_pager(const std::wstring &filename, const char *encoding = NULL);

      file_pager(const char *text, int len, const char *encoding = NULL);
    public:
      static util::ref_ptr<file_pager> create()
      {
        return new file_pager;
      }

      static util::ref_ptr<file_pager> create(const std::string &filename, const char *encoding=NULL)
      {
        return new file_pager(filename, encoding);
      }

      static util::ref_ptr<file_pager>
      create(const std::wstring &filename, const char *encoding=NULL)
      {
        return new file_pager(filename, encoding);
      }

      static util::ref_ptr<file_pager>
      create(const char *text, int len, const char *encoding=NULL)
      {
        return new file_pager(text, len, encoding);
      }

      void load_file(const std::string &filename, const char *encoding=NULL);

      void load_file(const std::wstring &filename, const char *encoding);

      void load_file(const std::wstring &filename);
    };

    typedef util::ref_ptr<pager> pager_ref;
    typedef util::ref_ptr<file_pager> file_pager_ref;
  }
}

#endif

---