gui.cpp

Go to the documentation of this file.

#include "gui.hpp"
#include "structs.hpp"
#include "version.hpp"
 
#include <boost/bind.hpp>
#include <sys/ioctl.h>
#include <boost/ref.hpp>
#include <sstream>
#include <fstream>
 
/**
 * \author cpellegrino
 */
 
const static int default_hit_counter_threshold = 850;
 
std::string mon_channel::mac_address() const
{
  /*
   * The MAC address of a WR node starts with 08:00:30.
   * The DOMID is defined by the MAC address removing the initial 08:00.
   */
 
  std::ostringstream oss("0800", std::ostringstream::ate);
  oss << std::hex << domid();
  if (oss.tellp() != 12) {
    return "undefined";
  }
 
  std::ostringstream stream;
 
  std::string const no = oss.str();
  std::size_t const s = no.size();
  for (std::size_t i = 0; i < s; i += 2) {
    stream << char(toupper(no[i]))
           << char(toupper(no[i + 1]))
           << (i != s - 2 ? ":" : "");
  }
  return stream.str();
}
 
inline
bool ischar(int key)
{
  return
      key >= std::numeric_limits<char>::min()
   && key <= std::numeric_limits<char>::max();
}
 
void async_commit(
      boost::asio::deadline_timer& timer,
      gui::Screen& screen,
      boost::system::error_code const& error)
{
  if (!error) {
    screen.commit();
 
    timer.expires_from_now(boost::posix_time::seconds(1));
    timer.async_wait(
        boost::bind(
            async_commit,
            boost::ref(timer),
            boost::ref(screen),
            boost::asio::placeholders::error));
  }
}
 
void async_cin(
    boost::asio::posix::stream_descriptor& keyb,
    char& key,
    gui::Screen& screen,
    const boost::system::error_code& error,
    std::size_t bytes_transferred)
{
  if (!error) {
    int k = key;
 
    if (key == 27) {
      boost::asio::posix::stream_descriptor::bytes_readable command(true);
      keyb.io_control(command);
 
      std::size_t nbytes = command.get();
 
      while (nbytes--) {
        boost::system::error_code ec;
        keyb.read_some(boost::asio::buffer(&key, sizeof(key)), ec);
        k <<= 8;
        k += key;
      }
    }
 
    screen.elaborate(k);
 
    keyb.async_read_some(
    boost::asio::buffer(&key, sizeof(key)),
    boost::bind(
        async_cin,
        boost::ref(keyb),
        boost::ref(key),
        boost::ref(screen),
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));
  }
}
 
void async_win_resize(
    boost::asio::signal_set& window_resize,
    gui::Screen& screen,
    boost::system::error_code const& error,
    int signum)
{
  if (!error) {
    std::pair<int, int> const win_size = window_size();
 
    screen.resize(win_size.first, win_size.second);
 
    window_resize.async_wait(
        boost::bind(
            async_win_resize,
            boost::ref(window_resize),
            boost::ref(screen),
            boost::asio::placeholders::error,
            boost::asio::placeholders::signal_number));
  }
}
 
std::pair<int, int> window_size()
{
  winsize sz;
 
  ioctl(0, TIOCGWINSZ, &sz);
 
  return std::make_pair(sz.ws_row, sz.ws_col);
}
 
namespace gui {
 
std::string const Screen::search_prompt = "Search: ";
std::string const Screen::regex_prompt  = "RegEx: ";
 
void LineEdit::move(LineEdit::movement dir)
{
  switch (dir) {
    case LEFT:
      m_current_pos -= m_current_pos == 0 ? 0 : 1;
      break;
    case RIGHT:
      m_current_pos += m_current_pos == m_current_line.size() ? 0 : 1;
      break;
    case BEGIN:
      m_current_pos = 0;
      break;
    case END:
      m_current_pos = m_current_line.size();
      break;
    case HBACK:
      if (not m_history.empty()) {
        if (m_history_pos == m_history.size()) {
          m_editing_line.swap(m_current_line);
        }
 
        if (m_history_pos != 0) {
          --m_history_pos;
 
          std::list<std::string>::iterator it = m_history.begin();
          std::advance(it, m_history_pos);
 
          m_current_line = *it;
          m_current_pos = m_current_line.size();
        }
      }
      break;
    case HFWD:
      if (not m_history.empty()) {
        if (m_history_pos == m_history.size() - 1) {
          m_editing_line.swap(m_current_line);
          ++m_history_pos;
          m_current_pos = m_current_line.size();
        } else if (m_history_pos < m_history.size()) {
          ++m_history_pos;
 
          std::list<std::string>::iterator it = m_history.begin();
          std::advance(it, m_history_pos);
 
          m_current_line = *it;
          m_current_pos = m_current_line.size();
        }
      }
      break;
  }
}
 
void LineEdit::load_history(std::string const& path)
{
  std::ifstream ifs(path.c_str());
 
  while (ifs && ifs.peek() != EOF) {
    std::string line;
    std::getline(ifs, line);
 
    m_history.push_back(line);
  }
}
 
void LineEdit::store_history(std::string const& path) const
{
  std::ofstream ofs(path.c_str());
  typedef std::list<std::string>::const_iterator citer;
  for (
      citer it = m_history.begin(), et = m_history.end()
    ; it != et
    ; ++it
  ) {
    ofs << *it << '\n';
  }
}
 
void Screen::elaborate(int key)
{
  if (status != kSEARCH && status != kREGEX) {
    clear_status_bar();
 
    if (key == 'q') {
      m_service.stop();
      return;
    }
  }
 
  switch (status) {
      case kNORMAL:
        if (key == 'h') {
          show_help();
          status = kHELP;
        } else if (key == 'c') {
          m_list.clear();
          m_smatched.clear();
          m_selected = 0;
          commit();
        } else if (key == 't') {
          sort = kLAST_VIEW;
          commit();
        } else if (key == 'd') {
          sort = kDOMID;
          commit();
        } else if (key == 'r') {
          sort = kRATE;
          commit();
        } else if (key == 'n') {
          sort = kRUNNO;
          commit();
        } else if (key == 'l') {
          sort = kNAME;
          commit();
        } else if (key == 'i') {
          m_sort_reverse = !m_sort_reverse;
          commit();
        } else if (key == 'g') {
          if (m_list.size()) {
            m_selected = 0;
 
            move_limits();
 
            move_selection();
          }
        } else if (key == 'G') {
          if (m_list.size()) {
            m_selected = m_list.size() - 1;
 
            move_limits();
 
            move_selection();
          }
        } else if (key == '/') {
          status = kSEARCH;
          m_search_editor.reset();
          update_bar(search_prompt, m_search_editor);
        } else if (key == '%') {
          status = kREGEX;
          m_regex_editor.reset();
          update_bar(regex_prompt, m_regex_editor);
        } else if (key == 'm') {
          m_matching_first = ! m_matching_first;
 
          if (m_matching_first) {
            write_to_status_bar("Grouping matching CLBs on top");
          } else {
            write_to_status_bar("Grouping disabled");
          }
        } else if (key == 'w') {
          go_match = NONE;
          m_smatched.clear();
        } else if (key == kKEY_ENTER) {
          if (m_list.size()) {
            status = kSINGLE;
            show_filtered();
          } else {
            status_nodoms();
          }
        } else if (key == kKEY_DOWN) {
          if (m_list.size()) {
            m_selected =
                m_selected + 1 == static_cast<int>(m_list.size())
                ? 0
                : m_selected + 1;
 
            move_limits();
 
            move_selection();
          }
        } else if (key == kKEY_UP) {
          if (m_list.size()) {
            m_selected =
                m_selected - 1 < 0
                ? m_list.size() - 1
                : m_selected - 1;
 
            move_limits();
 
            move_selection();
          }
        } else if (key == kKEY_LEFT) {
          if (m_offset != 0) {
            m_offset -= 5;
            commit();
          }
        } else if (key == kKEY_RIGHT) {
          if (m_offset + COLS + 1 < max_line_size) {
            m_offset += 5;
            commit();
          }
        } else {
          status_unrecognised(key);
        }
        break;
      case kHELP:
        if (key == kKEY_ESC) {
          status = kNORMAL;
          commit();
        } else {
          status_unrecognised(key);
        }
        break;
      case kSINGLE:
        if (key == kKEY_ESC) {
          status = kNORMAL;
          commit();
        } else if (key == kKEY_DOWN) {
          if (m_list.size()) {
            m_selected =
                m_selected + 1 == static_cast<int>(m_list.size())
                ? 0
                : m_selected + 1;
 
            move_limits();
 
            move_selection();
          }
        } else if (key == kKEY_UP) {
          if (m_list.size()) {
            m_selected =
                m_selected - 1 < 0
                ? m_list.size() - 1
                : m_selected - 1;
 
            move_limits();
 
            move_selection();
          }
        } else {
          status_unrecognised(key);
        }
        break;
      case kSEARCH:
        if (key == kKEY_ESC) {
          clear_status_bar();
 
          if (!m_search_editor.current().empty()) {
            m_search_editor.add_history();
          }
 
          status = kNORMAL;
          go_match = NONE;
          m_smatched.clear();
          return;
        } else if (key == kKEY_ENTER) {
          go_match = SEARCH;
          m_search_editor.add_history();
          clear_status_bar();
          status = kNORMAL;
          return;
        } else if (key == kKEY_UP) {
          m_search_editor.move(LineEdit::HBACK);
        } else if (key == kKEY_DOWN) {
          m_search_editor.move(LineEdit::HFWD);
        } else if (key == kKEY_RIGHT) {
          m_search_editor.move(LineEdit::RIGHT);
        } else if (key == kKEY_LEFT) {
          m_search_editor.move(LineEdit::LEFT);
        } else if (key == kKEY_BACKS) {
          m_search_editor.remove_bwd();
        } else if (key == kKEY_DEL) {
          m_search_editor.remove_fwd();
        } else if (key == kKEY_HOME || key == kKEY_CTRLA) {
          m_search_editor.move(LineEdit::BEGIN);
        } else if (key == kKEY_END || key == kKEY_CTRLE) {
          m_search_editor.move(LineEdit::END);
        } else if (key == kKEY_CTRLL) {
          m_search_editor.reset();
        } else if (ischar(key) && isprint(key)) {
          m_search_editor.append(key);
        } else {
          return;
        }
        update_bar(search_prompt, m_search_editor);
        go_match = SEARCH;
        commit();
        break;
      case kREGEX:
        if (key == kKEY_ESC) {
          clear_status_bar();
          status = kNORMAL;
          return;
        } else if (key == kKEY_ENTER) {
          if (!m_regex_editor.current().empty()) {
            m_regex_editor.add_history();
          }
 
          std::string const current_line = m_regex_editor.current();
          m_regex_editor.reset();
          clear_status_bar();
          status = kNORMAL;
 
          try {
            m_regex.assign(current_line, boost::regex_constants::icase);
            go_match = REGEX;
            commit();
          } catch (...) {
            write_to_status_bar("Invalid regex");
            go_match = NONE;
            m_smatched.clear();
          }
          return;
        } else if (key == kKEY_UP) {
          m_regex_editor.move(LineEdit::HBACK);
        } else if (key == kKEY_DOWN) {
          m_regex_editor.move(LineEdit::HFWD);
        } else if (key == kKEY_RIGHT) {
          m_regex_editor.move(LineEdit::RIGHT);
        } else if (key == kKEY_LEFT) {
          m_regex_editor.move(LineEdit::LEFT);
        } else if (key == kKEY_BACKS) {
          m_regex_editor.remove_bwd();
        } else if (key == kKEY_DEL) {
          m_regex_editor.remove_fwd();
        } else if (key == kKEY_HOME || key == kKEY_CTRLA) {
          m_regex_editor.move(LineEdit::BEGIN);
        } else if (key == kKEY_END || key == kKEY_CTRLE) {
          m_regex_editor.move(LineEdit::END);
        } else if (key == kKEY_CTRLL) {
          m_regex_editor.reset();
        } else if (ischar(key) && isprint(key)) {
          m_regex_editor.append(key);
        } else {
          return;
        }
        update_bar(regex_prompt, m_regex_editor);
        break;
      default:
        assert(! "Internal screen error");
  }
}
 
void Screen::update_bar(std::string const& prompt, LineEdit const& le)
{
  werase(m_twin);
  wprintw(m_twin, "%s", prompt.c_str());
  wprintw(m_twin, "%s", le.current().c_str());
  wmove(m_twin, 0, le.cursor() + prompt.size());
  wnoutrefresh(m_twin);
  doupdate();
}
 
void Screen::show_help() const
{
  int const col1 = 2;
  int const col2 = 33;
 
  int const cols = 70;
  int const lines = 16;
  int const x_pos = (COLS - cols) / 2;
  int const y_pos = (LINES - lines) / 2;
  WINDOW* help_win = newwin(lines, cols, y_pos, x_pos);
  box(help_win, 0, 0);
  wmove(help_win, 0, 6);
  wprintw(help_win, " Help ");
  wmove(help_win, 1, col1);
  wprintw(help_win, "Press the key to activate the corresponding behaviour.");
  wmove(help_win, 3, col1);
  wprintw(help_win, "Sort:");
  wmove(help_win, 4, col1);
  wprintw(help_win, "- t: sort by last view time");
  wmove(help_win, 5, col1);
  wprintw(help_win, "- d: sort by DOM ID");
  wmove(help_win, 6, col1);
  wprintw(help_win, "- r: sort by avg hit rate");
  wmove(help_win, 7, col1);
  wprintw(help_win, "- n: sort by run number");
  wmove(help_win, 8, col1);
  wprintw(help_win, "- l: sort by label (name)");
  wmove(help_win, 9, col1);
  wprintw(help_win, "- i: invert sorting");
  wmove(help_win, 3, col2);
  wprintw(help_win, "Screen:");
  wmove(help_win, 4, col2);
  wprintw(help_win, "- c: clear the screen");
  wmove(help_win, 5, col2);
  wprintw(help_win, "- Arrow keys: move selection/view");
  wmove(help_win, 6, col2);
  wprintw(help_win, "- g: move selection to top");
  wmove(help_win, 7, col2);
  wprintw(help_win, "- G: move selection to bottom");
  wmove(help_win, 8, col2);
  wprintw(help_win, "- /: open search prompt");
  wmove(help_win, 9, col2);
  wprintw(help_win, "- %%: open regex prompt");
  wmove(help_win, 10, col2);
  wprintw(help_win, "- w: wipe the search/regex status");
  wmove(help_win, 11, col2);
  wprintw(help_win, "- m: toggle grouping matches on top");
  wmove(help_win, 13, col1);
  wprintw(help_win, "Press ESC to dismiss this win");
  wmove(help_win, 14, col1);
  wprintw(help_win, "Version %s", clbsk::version::v().c_str());
 
  wnoutrefresh(help_win);
  delwin(help_win);
  reset_cursor();
}
 
bool is_problematic(mon_channel const& channel)
{
  return
    ! channel.syncd()
   || channel.mean() > default_hit_counter_threshold
   || boost::chrono::duration_cast<boost::chrono::seconds>(channel.last_view())
    > boost::chrono::seconds(2);
}
 
void Screen::write_head() const
{
  bool const problematic = std::find_if(
      m_list.begin()
    , m_list.end()
    , is_problematic
  ) != m_list.end();
 
  werase(m_hwin);
  wmove(m_hwin, 0, 0);
 
  if (m_smatched.empty()) {
    wprintw(
        m_hwin
      , "CLBSK - %s - # CLBs:%c %ld - 'q' to quit, 'h' for help"
      , m_heading.c_str()
      , problematic ? '!' : ' '
      , m_list.size()
    );
  } else {
    wprintw(
        m_hwin
      , "CLBSK - %s - # CLBs:%c %ld (%ld) - 'q' to quit, 'h' for help"
      , m_heading.c_str()
      , problematic ? '!' : ' '
      , m_list.size()
      , m_smatched.size()
    );
  }
 
  wnoutrefresh(m_hwin);
  reset_cursor();
}
 
void Screen::write_page()
{
  werase(m_cwin);
  box(m_cwin, 0, 0);
  if (m_upper != 0) {
    mvwaddstr(m_cwin, 0, 3, "^");
  }
 
  if (m_lower < static_cast<int>(m_list.size())) {
    mvwaddstr(m_cwin, LINES - 3, 3, "v");
  }
 
  wmove(m_cwin, 1, 2);
  print_table_head(m_cwin, m_offset);
 
  int count = 1;
  typedef ChList::const_iterator citerator;
 
  citerator it = m_list.begin(), et = m_list.end();
  std::advance(it, m_upper);
 
  for (int vcount = m_upper; it != et && vcount < m_lower; ++vcount, ++it) {
    wmove(m_cwin, ++count, 2);
    print_chan(
        m_cwin
      , it
      , m_linebuffer
      , COLS + m_offset - 3
      , m_offset
      , std::find(m_smatched.begin(), m_smatched.end(), it) != m_smatched.end()
    );
 
    if (count - 2 == m_selected - m_upper) {
      mvwaddstr(m_cwin, count, 1, ">");
    }
  }
  wnoutrefresh(m_cwin);
  reset_cursor();
}
 
void Screen::move_limits()
{
  if (m_upper > m_selected) {
    m_upper = m_selected;
    m_lower = m_upper + LINES - 5;
  }
  if (m_lower <= m_selected) {
    m_lower = m_selected + 1;
    m_upper = m_lower - LINES + 5;
  }
}
 
void Screen::show_filtered(CLBCommonHeader const* header)
{
  ChList::const_iterator it = m_list.begin();
  std::advance(it, m_selected);
 
  if (header->domIdentifier() == it->domid()) {
    werase(m_cwin);
    box(m_cwin, 0, 0);
    wmove(m_cwin, 1, 2);
    wprintw(m_cwin, "Press ESC to return back.");
 
    wmove(m_cwin, 2, 2);
    print_table_head(m_cwin, 0);
    wmove(m_cwin, 3, 2);
    print_chan(m_cwin, it, m_linebuffer, COLS - 3, 0, false);
 
    uint32_t const*const data = static_cast<uint32_t const*>(
        static_cast<void const*>(header + 1));
 
    wmove(m_cwin, 5, 2);
 
    bool const valid = validTimeStamp(*header);
 
    print_timestamp(
        m_cwin,
        header->timeStamp(),
        m_linebuffer,
        COLS - 3,
        0,
        valid);
 
    wmove(m_cwin, 7, 2);
 
    for (int i = 0; i < 31; ++i) {
      wprintw(m_cwin, "CH%02d: %5d", i, ntohl(data[i]));
 
      int y = 0, x = 0;
      getyx(m_cwin, y, x);
 
      if (x + 15 > COLS) {
        wmove(m_cwin, y + 1, 2);
      } else {
        wmove(m_cwin, y, x + 2);
      }
    }
 
    int y = 0, x = 0;
    getyx(m_cwin, y, x);
 
    char const*const raw_data = static_cast<char const*>(
        static_cast<void const*>(header));
 
    SCData const*const scdata = static_cast<SCData const*>(
        static_cast<void const*>(
            raw_data + sizeof(*header) + 31 * sizeof(uint32_t)));
 
    wmove(m_cwin, y + 2, 2);
    wprintw(m_cwin, "Validity: 0x%x", ntohl(scdata->valid));
 
    wmove(m_cwin, y + 3, 2);
    wprintw(
        m_cwin,
        "Yaw: %4.4f  Pitch: %4.4f  Roll: %4.4f deg",
        ntohl_f(scdata->ahrs.yaw),
        ntohl_f(scdata->ahrs.pitch),
        ntohl_f(scdata->ahrs.roll));
 
    wmove(m_cwin, y + 4, 2);
    wprintw(
        m_cwin,
        "Acceleration: %4.4f, %4.4f, %4.4f g",
        ntohl_f(scdata->ahrs.ax),
        ntohl_f(scdata->ahrs.ay),
        ntohl_f(scdata->ahrs.az));
 
    wmove(m_cwin, y + 5, 2);
    wprintw(
        m_cwin,
        "Gyroscope: %4.4f, %4.4f, %4.4f deg/sec",
        ntohl_f(scdata->ahrs.gx),
        ntohl_f(scdata->ahrs.gy),
        ntohl_f(scdata->ahrs.gz));
 
    wmove(m_cwin, y + 6, 2);
    wprintw(m_cwin,
    "Compass: %4.4f, %4.4f, %4.4f gauss",
    ntohl_f(scdata->ahrs.hx),
    ntohl_f(scdata->ahrs.hy),
    ntohl_f(scdata->ahrs.hz));
 
    wmove(m_cwin, y + 7, 2);
    wprintw(m_cwin, "Temperature: %.2f Celsius", ntohs(scdata->temp) / 100.);
 
    wmove(m_cwin, y + 8, 2);
    wprintw(m_cwin, "Humidity: %.2f RH", ntohs(scdata->humidity) / 100.);
 
    wnoutrefresh(m_cwin);
    reset_cursor();
  }
}
 
bool matches(mon_channel const& ch, std::string const& pattern)
{
  return
      pattern.size() != 0
   && (
          ch.name().find(pattern)                                    != std::string::npos
       || ch.mac_address().find(pattern)                             != std::string::npos
       || boost::lexical_cast<std::string>(ch.domid()).find(pattern) != std::string::npos
      );
}
 
void Screen::search()
{
  m_smatched.clear();
 
  for (
      ChList::const_iterator it = m_list.begin(), et = m_list.end()
    ; it != et
    ; ++it
  ) {
    if (matches(*it, m_search_editor.current())) {
      m_smatched.push_back(it);
    }
  }
}
 
bool matches(mon_channel const& ch, boost::regex const& regex)
{
  return
      boost::regex_match(ch.name(), regex)
   || boost::regex_match(ch.mac_address(), regex)
   || boost::regex_match(boost::lexical_cast<std::string>(ch.domid()), regex);
}
 
void Screen::filter()
{
  m_smatched.clear();
 
  for (
      ChList::const_iterator it = m_list.begin(), et = m_list.end()
    ; it != et
    ; ++it
  ) {
    if (matches(*it, m_regex)) {
      m_smatched.push_back(it);
    }
  }
}
 
bool Screen::is_filter() const
{
  return status == kSINGLE;
}
 
bool Screen::is_user_input() const
{
  return status >= kSEARCH;
}
 
class domid_comparator
{
  bool m_reverse;
 
 public:
 
  explicit
  domid_comparator(bool reverse)
    :
    m_reverse(reverse)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    return m_reverse
        ? first.domid() < second.domid()
        : first.domid() > second.domid();
  }
};
 
class last_view_comparator
{
  bool m_reverse;
 
 public:
 
  explicit
  last_view_comparator(bool reverse)
    :
    m_reverse(reverse)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    using namespace boost::chrono;
    return m_reverse
        ? duration_cast<seconds>(first.last_view()) < duration_cast<seconds>(second.last_view())
        : duration_cast<seconds>(first.last_view()) > duration_cast<seconds>(second.last_view());
  }
};
 
class hit_rate_comparator
{
  bool m_reverse;
 
 public:
 
  explicit
  hit_rate_comparator(bool reverse)
    :
    m_reverse(reverse)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    return m_reverse
        ? first.mean() < second.mean()
        : first.mean() > second.mean();
  }
};
 
class run_number_comparator
{
  bool m_reverse;
 
 public:
 
  explicit
  run_number_comparator(bool reverse)
    :
    m_reverse(reverse)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    return m_reverse
        ? first.run_number() < second.run_number()
        : first.run_number() > second.run_number();
  }
};
 
class name_comparator
{
  bool m_reverse;
 
 public:
 
  explicit
  name_comparator(bool reverse)
    :
    m_reverse(reverse)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    return m_reverse
        ? first.name() < second.name()
        : first.name() > second.name();
  }
};
 
class match_comparator
{
  std::list<ChList::const_iterator> const* m_matching;
 
  bool belongs(mon_channel const& ch)
  {
    typedef std::list<ChList::const_iterator>::const_iterator citer;
    for (
        citer it = m_matching->begin(), et = m_matching->end()
      ; it != et
      ; ++it
    ) {
      if ((*(*it)).domid() == ch.domid()) {
        return true;
      }
    }
 
    return false;
  }
 
 public:
 
  match_comparator(
    std::list<ChList::const_iterator> const& matching
  ) : m_matching(&matching)
  {}
 
  bool operator ()(mon_channel const& first, mon_channel const& second)
  {
    bool const first_matches = belongs(first);
    bool const second_matches = belongs(second);
 
    return first_matches || !second_matches;
  }
};
 
void Screen::sort_channels()
{
  switch (sort) {
    case kDOMID:
      m_list.sort(domid_comparator(m_sort_reverse));
      break;
    case kLAST_VIEW:
      m_list.sort(last_view_comparator(m_sort_reverse));
      break;
    case kRATE:
      m_list.sort(hit_rate_comparator(m_sort_reverse));
      break;
    case kRUNNO:
      m_list.sort(run_number_comparator(m_sort_reverse));
      break;
    case kNAME:
      m_list.sort(name_comparator(m_sort_reverse));
      break;
    default:
      assert(!"Sort internal error");
  }
 
  if (m_matching_first && !m_smatched.empty() && go_match != NONE) {
    m_list.sort(match_comparator(m_smatched));
  }
}
 
void print_table_head(WINDOW* win, int offset)
{
  static const char head[] =
      "DOMID      MAC ADDRESS       Name     Run #   Hit rate (min, max, avg)       Last viewed   S Delta time";
 
  if (static_cast<int>(strlen(head)) > offset) {
    int const max_in_string = strlen(head) - offset;
    int const nchars =  std::min(COLS - 4, max_in_string);
    wprintw(win, "%.*s", nchars, head + offset);
  }
}
 
void print_chan(
    WINDOW* win
  , ChList::const_iterator const& it
  , std::vector<char>& buffer
  , int line_size
  , int offset
  , bool highlight
) {
  assert(offset <= line_size);
 
  int const last_view = boost::chrono::duration_cast<boost::chrono::seconds>(
      it->last_view()
  ).count();
 
  int const size = snprintf(
      &buffer.front(),
      line_size,
      "%-9d  %-17s %-8s %-6u  %7.2f, %7.2f, %7.2f kHz  %4d sec ago  %s %ld ms",
      it->domid(),
      it->mac_address().c_str(),
      it->name().c_str(),
      it->run_number(),
      it->min() / 100.,
      it->max() / 100.,
      it->mean() / 100.,
      last_view,
      it->syncd() ? "*" : " ",
      it->avg_delta_time());
 
  if (offset < std::min(line_size, size)) {
    if (highlight) {
      wattron(win, A_REVERSE);
    } else {
      wattroff(win, A_REVERSE);
    }
 
    if (!it->syncd()) {
      wattron(win, NOSYNC);
    }
 
    if (it->mean() > default_hit_counter_threshold) {
      wattron(win, HIRATE);
    }
 
    if (last_view > 2) {
      wattron(win, NODATA);
    }
 
    wprintw(win, "%s", &buffer[offset]);
 
    if (size > line_size) {
      wprintw(win, "$");
    }
  }
 
  wattrset(win, GROUND);
}
 
void print_timestamp(
    WINDOW* win,
    UTCTime const& tstamp,
    std::vector<char>& buffer,
    int line_size,
    int offset,
    bool validity)
{
  assert(offset <= line_size);
 
  std::ostringstream oss;
 
  oss << UTCTime_h(tstamp, validity);
 
  int const size = snprintf(
      &buffer.front(),
      line_size,
      "Sec: %d, Tic: %-8d - %s",
      tstamp.sec(),
      tstamp.tics(),
      oss.str().c_str());
 
  if (offset < std::min(line_size, size)) {
    wprintw(win, "%s", &buffer[offset]);
 
    if (size > line_size) {
      wprintw(win, "$");
    }
  }
}
 
} // ns gui