Subversion Repositories pcie_ds_dma

 
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <ncurses.h>
#include <signal.h>
#include <vector>
 
#ifndef __NCTABLE_H__
#include "nctable.h"
#endif
 
//-----------------------------------------------------------------------------
 
void table::init()
{
    initscr();
    cbreak();
    noecho();
    keypad(stdscr, TRUE);
    nonl();
}
 
//-----------------------------------------------------------------------------
 
table::table(int cell_width, int cell_height)
{
    init();
 
    m_row = 0;
    m_colomn = 0;
    m_CW = cell_width;
    m_CH = cell_height;
    m_table.clear();
 
    getmaxyx(stdscr,m_maxH,m_maxW);
 
    m_W0 = m_maxW/2;
    m_H0 = m_maxH/2;
 
    m_header.w = NULL;
    m_header.X0 = m_header.Y0 = m_header.W = m_header.H = 0;
    m_status.clear();
    //m_status.w = NULL;
    //m_status.X0 = m_status.Y0 = m_status.W = m_status.H = 0;
}
 
//-----------------------------------------------------------------------------
 
table::table(int colomn_number, int cell_width, int cell_height)
{
    init();
 
    m_row = 0;
    m_colomn = colomn_number;
    m_CW = cell_width;
    m_CH = cell_height;
    m_table.clear();
 
    getmaxyx(stdscr,m_maxH,m_maxW);
 
    m_W0 = m_maxW/2;
    m_H0 = m_maxH/2;
 
    m_header.w = NULL;
    m_header.X0 = m_header.Y0 = m_header.W = m_header.H = 0;
    m_status.clear();
    //m_status.w = NULL;
    //m_status.X0 = m_status.Y0 = m_status.W = m_status.H = 0;
}
 
//-----------------------------------------------------------------------------
 
table::table(int row, int col, int cell_width, int cell_height)
{
    init();
 
    m_row = row;
    m_colomn = col;
    m_CW = cell_width;
    m_CH = cell_height;
 
    getmaxyx(stdscr,m_maxH,m_maxW);
 
    m_W0 = m_maxW/2;
    m_H0 = m_maxH/2;
 
    m_header.w = NULL;
    m_header.X0 = m_header.Y0 = m_header.W = m_header.H = 0;
    m_status.clear();
    //m_status.w = NULL;
    //m_status.X0 = m_status.Y0 = m_status.W = m_status.H = 0;
 
    create_table(row, col);
}
 
//-----------------------------------------------------------------------------
 
table::~table()
{
    clear_table();
    clear_header();
    clear_status();
    endwin();
}
 
//-----------------------------------------------------------------------------
 
void table::clear_table()
{
    for(unsigned i=0; i<m_table.size(); i++) {
        row_t row = m_table.at(i);
        for(unsigned j=0; j<row.w.size(); j++) {
            WINDOW *w = row.w.at(j);
            delwin(w);
        }
        row.w.clear();
    }
    m_table.clear();
}
 
//-----------------------------------------------------------------------------
 
int table::create_table(int nrow, int ncol)
{
    clear_table();
 
    int dX = m_CW * ncol/2;
    int dY = m_CH * nrow/2;
 
    for(int row = 0; row < nrow; row++) {
 
        int x0 = m_W0 - dX;
        int y0 = m_H0 + m_CH * row - dY;
 
        row_t new_row;
 
        new_row.X0 = x0;
        new_row.Y0 = y0;
 
        for(int col = 0; col < ncol; col++) {
 
            int xn = x0 + m_CW * col;
            int yn = y0;
 
            WINDOW *w = newwin(m_CH, m_CW, yn, xn);
            if(!w)
                break;
            box(w, 0 , 0);
            wrefresh(w);
            new_row.w.push_back(w);
        }
 
        m_table.push_back(new_row);
    }
 
    return m_table.size();
}
 
//-----------------------------------------------------------------------------
 
int table::add_row()
{
    int x0 = 0;
    int y0 = 0;
 
    if(m_table.size()) {
 
        x0 = m_W0 - m_CW * m_colomn/2;
        y0 = m_H0 - m_H0/2 + m_CH * m_table.size();
 
    } else {
 
        x0 = m_W0 - m_CW * m_colomn/2;
        y0 = m_H0 - m_H0/2;
    }
 
    row_t new_row;
 
    new_row.X0 = x0;
    new_row.Y0 = y0;
 
    for(int col = 0; col < m_colomn; col++) {
 
        int xn = x0 + m_CW * col;
        int yn = y0;
 
        WINDOW *w = newwin(m_CH, m_CW, yn, xn);
        if(!w)
            break;
            box(w, 0 , 0);
            wrefresh(w);
            new_row.w.push_back(w);
    }
 
    m_table.push_back(new_row);
 
    return m_table.size();
}
 
//-----------------------------------------------------------------------------
 
int table::set_cell_text(unsigned nrow, unsigned ncol, const char *fmt, ...)
{
    if(nrow >= m_table.size())
        return -1;
 
    row_t& row = m_table.at(nrow);
 
    if(ncol >= row.w.size())
        return -2;
 
    WINDOW *w = row.w.at(ncol);
 
    if(!w)
        return -3;
 
    va_list argptr;
    va_start(argptr, fmt);
    char msg[256];
    vsprintf(msg, fmt, argptr);
    wmove(w, m_CH/2, m_CW/2-strlen(msg)/2);
    wprintw(w, "%s", msg);
    wrefresh(w);
 
    return 0;
}
 
//-----------------------------------------------------------------------------
 
bool table::create_header()
{
    if(m_header.w)
        return true;
 
    if(m_table.empty())
        return false;
 
    row_t row0 = m_table.at(0);
 
    m_header.X0 = row0.X0;
    m_header.Y0 = row0.Y0-m_CH;
 
    m_header.H = m_CH;
    m_header.W = m_CW*row0.w.size();
 
    WINDOW *w = newwin(m_header.H, m_header.W, m_header.Y0, m_header.X0);
    if(!w) {
        return false;
    }
 
    m_header.w = w;
    box(w, 0 , 0);
 
    wrefresh(w);
 
    return true;
}
 
//-----------------------------------------------------------------------------
 
bool table::create_status()
{
    if(m_table.empty())
        return false;
 
    struct header_t status_bar;
 
    if(m_status.empty()) {
 
        row_t rowN = m_table.at(m_table.size()-1);
 
        status_bar.X0 = rowN.X0;
        status_bar.Y0 = rowN.Y0+m_CH;
 
        status_bar.H = m_CH;
        status_bar.W = m_CW*rowN.w.size();
 
    } else {
 
        struct header_t last_bar = m_status.at(m_status.size()-1);
 
        status_bar.X0 = last_bar.X0;
        status_bar.Y0 = last_bar.Y0+m_CH;
 
        status_bar.H = m_CH;
        status_bar.W = last_bar.W;
    }
 
    WINDOW *w = newwin(status_bar.H, status_bar.W, status_bar.Y0, status_bar.X0);
    if(!w) {
        return false;
    }
 
    status_bar.w = w;
    box(status_bar.w, 0 , 0);
    wrefresh(w);
 
    m_status.push_back(status_bar);
 
    return true;
}
 
//-----------------------------------------------------------------------------
 
int table::set_header_text(const char *fmt, ...)
{
    if(!m_header.w)
        return -1;
 
    va_list argptr;
    va_start(argptr, fmt);
    char msg[256];
    vsprintf(msg, fmt, argptr);
    wmove(m_header.w, m_header.H/2, m_header.W/2-strlen(msg)/2);
    wprintw(m_header.w, "%s", msg);
    wrefresh(m_header.w);
 
    return 0;
}
 
//-----------------------------------------------------------------------------
 
int table::set_status_text(unsigned id, const char *fmt, ...)
{
    if(id >= m_status.size())
        return -1;
 
    struct header_t status_bar = m_status.at(id);
    if(!status_bar.w)
        return -1;
 
    va_list argptr;
    va_start(argptr, fmt);
    char msg[256];
    vsprintf(msg, fmt, argptr);
    wmove(status_bar.w, status_bar.H/2, status_bar.W/2-strlen(msg)/2);
    wprintw(status_bar.w, "%s", msg);
    wrefresh(status_bar.w);
 
    return 0;
}
 
//-----------------------------------------------------------------------------
 
void table::clear_status()
{
    for(unsigned i=0; i<m_status.size(); i++) {
        struct header_t status_bar = m_status.at(i);
        if(status_bar.w) {
            delwin(status_bar.w);
            status_bar.w = NULL;
        }
    }
    m_status.clear();
}
 
//-----------------------------------------------------------------------------
 
void table::clear_header()
{
    if(m_header.w) {
        delwin(m_header.w);
        m_header.w = NULL;
    }
}
 
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------