term.h File Reference

#include <inttypes.h>
#include <stdio.h>

Go to the source code of this file.

Classes
struct	_term_t

Macros
#define	TERM_ATTR_BACK_MASK   0x00
#define	TERM_ATTR_BACK_BLACK   0x00
#define	TERM_ATTR_BACK_WHITE   0x00
#define	TERM_ATTR_TEXT_MASK   0x00
#define	TERM_ATTR_TEXT_BLACK   0x00
#define	TERM_ATTR_TEXT_WHITE   0x00
#define	TERM_ATTR_INVERT   0x40
#define	TERM_ATTR_BLINK   0x80
#define	TERM_COLOR_BLACK   0
#define	TERM_COLOR_RED   1
#define	TERM_COLOR_GREEN   2
#define	TERM_COLOR_YELLOW   3
#define	TERM_COLOR_BLUE   4
#define	TERM_COLOR_MAGENTA   5
#define	TERM_COLOR_CYAN   6
#define	TERM_COLOR_WHITE   7
#define	TERM_FLG_FREEMEM   0x0080
#define	TERM_FLG_CHANGED   0x0040
#define	TERM_FLG_ESCAPE   0x0020
#define	TERM_FLG_AUTOCR   0x0010
#define	TERM_DEF_CHAR   ' '
#define	TERM_DEF_ATTR   (TERM_ATTR_BACK_BLACK | TERM_ATTR_TEXT_WHITE)
#define	TERM_BUFF_SIZE(c, r)   ((r * c * 2) + (r * c + 7) / 8)
#define	TERM_PRINTF_MAX   0xff

Typedefs
typedef struct _term_t	term_t

Functions
void	term_init (term_t *pt, uint8_t cols, uint8_t rows, uint8_t *buff)
void	term_done (term_t *pt)
void	term_clear (term_t *pt)
uint8_t	term_get_char_at (term_t *pt, uint8_t col, uint8_t row)
void	term_set_char_at (term_t *pt, uint8_t col, uint8_t row, uint8_t ch)
uint8_t	term_get_attr_at (term_t *pt, uint8_t col, uint8_t row)
void	term_set_attr_at (term_t *pt, uint8_t col, uint8_t row, uint8_t attr)
void	term_set_attr (term_t *pt, uint8_t attr)
void	term_set_pos (term_t *pt, uint8_t col, uint8_t row)
void	term_write_char (term_t *pt, uint8_t ch)
int	term_printf (term_t *pt, const char *fmt,...)
int	vterm_printf (term_t *pt, const char *fmt, va_list va)

Macro Definition Documentation

TERM_ATTR_BACK_MASK

#define TERM_ATTR_BACK_MASK   0x00

TERM_ATTR_BACK_BLACK

#define TERM_ATTR_BACK_BLACK   0x00

TERM_ATTR_BACK_WHITE

#define TERM_ATTR_BACK_WHITE   0x00

TERM_ATTR_TEXT_MASK

#define TERM_ATTR_TEXT_MASK   0x00

TERM_ATTR_TEXT_BLACK

#define TERM_ATTR_TEXT_BLACK   0x00

TERM_ATTR_TEXT_WHITE

#define TERM_ATTR_TEXT_WHITE   0x00

TERM_ATTR_INVERT

#define TERM_ATTR_INVERT   0x40

TERM_ATTR_BLINK

#define TERM_ATTR_BLINK   0x80

TERM_COLOR_BLACK

#define TERM_COLOR_BLACK   0

TERM_COLOR_RED

#define TERM_COLOR_RED   1

TERM_COLOR_GREEN

#define TERM_COLOR_GREEN   2

TERM_COLOR_YELLOW

#define TERM_COLOR_YELLOW   3

TERM_COLOR_BLUE

#define TERM_COLOR_BLUE   4

TERM_COLOR_MAGENTA

#define TERM_COLOR_MAGENTA   5

TERM_COLOR_CYAN

#define TERM_COLOR_CYAN   6

TERM_COLOR_WHITE

#define TERM_COLOR_WHITE   7

TERM_FLG_FREEMEM

#define TERM_FLG_FREEMEM   0x0080

TERM_FLG_CHANGED

#define TERM_FLG_CHANGED   0x0040

TERM_FLG_ESCAPE

#define TERM_FLG_ESCAPE   0x0020

TERM_FLG_AUTOCR

#define TERM_FLG_AUTOCR   0x0010

TERM_DEF_CHAR

#define TERM_DEF_CHAR   ' '

TERM_DEF_ATTR

#define TERM_DEF_ATTR   (TERM_ATTR_BACK_BLACK | TERM_ATTR_TEXT_WHITE)

TERM_BUFF_SIZE

#define TERM_BUFF_SIZE	(		c,
			r
	)		((r * c * 2) + (r * c + 7) / 8)

TERM_PRINTF_MAX

#define TERM_PRINTF_MAX   0xff

Typedef Documentation

term_t

typedef struct _term_t term_t

Function Documentation

term_init()

void term_init	(	term_t *	pt,
		uint8_t	cols,
		uint8_t	rows,
		uint8_t *	buff
	)

                                                                      {
    if (!pt /*|| pt->buff*/)
        return;
    pt->cols = cols;
    pt->rows = rows;
    pt->size = cols * rows * 2;
    pt->flg = TERM_FLG_AUTOCR;
    if (buff)
        pt->buff = buff;
    else {
        pt->buff = (uint8_t *)gui_malloc(TERM_BUFF_SIZE(cols, rows));
        pt->flg |= TERM_FLG_FREEMEM;
    }
    pt->attr = TERM_DEF_ATTR;
    pt->col = 0;
    pt->row = 0;
    pt->file = 0;
    term_clear(pt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

term_done()

void term_done

(

term_t *

pt

)

                           {
    if (!pt || !(pt->buff))
        return;
    if (pt->flg & TERM_FLG_FREEMEM)
        gui_free(pt->buff);
    //pt->buff = 0;
}

Here is the call graph for this function:

term_clear()

void term_clear

(

term_t *

pt

)

                            {
    int r;
    int c;
    uint8_t *p = pt->buff;
    if (!pt || !(pt->buff))
        return;
    for (r = 0; r < pt->rows; r++)
        for (c = 0; c < pt->cols; c++) {
            *(p++) = TERM_DEF_CHAR;
            *(p++) = TERM_DEF_ATTR;
        }
    memset(pt->buff + pt->size, 0xff, 40 /*(pt->size + 15) >> 4*/);
    pt->col = 0;
    pt->row = 0;
    pt->flg |= TERM_FLG_CHANGED;
}

Here is the caller graph for this function:

term_get_char_at()

uint8_t term_get_char_at	(	term_t *	pt,
		uint8_t	col,
		uint8_t	row
	)

                                                               {
    if (!pt || !(pt->buff))
        return 0;
    if ((col >= pt->cols) || (row >= pt->rows))
        return 0;
    int i = col + row * pt->cols;
    return pt->buff[2 * i + 0];
}

term_set_char_at()

void term_set_char_at	(	term_t *	pt,
		uint8_t	col,
		uint8_t	row,
		uint8_t	ch
	)

                                                                        {
    if (!pt || !(pt->buff))
        return;
    if ((col >= pt->cols) || (row >= pt->rows))
        return;
    int i = col + row * pt->cols;
    pt->buff[2 * i + 0] = ch;
    pt->buff[pt->size + (i >> 3)] |= (1 << (i % 8));
    pt->flg |= TERM_FLG_CHANGED;
}

term_get_attr_at()

uint8_t term_get_attr_at	(	term_t *	pt,
		uint8_t	col,
		uint8_t	row
	)

                                                               {
    if (!pt || !(pt->buff))
        return 0;
    if ((col >= pt->cols) || (row >= pt->rows))
        return 0;
    int i = col + row * pt->cols;
    return pt->buff[2 * i + 1];
}

term_set_attr_at()

void term_set_attr_at	(	term_t *	pt,
		uint8_t	col,
		uint8_t	row,
		uint8_t	attr
	)

                                                                          {
    if (!pt || !(pt->buff))
        return;
    if ((col >= pt->cols) || (row >= pt->rows))
        return;
    int i = col + row * pt->cols;
    pt->buff[2 * i + 1] = attr;
    pt->buff[pt->size + (i >> 3)] |= (1 << (i % 8));
    pt->flg |= TERM_FLG_CHANGED;
}

term_set_attr()

void term_set_attr	(	term_t *	pt,
		uint8_t	attr
	)

                                             {
    if (!pt || !(pt->buff))
        return;
    pt->attr = attr;
}

term_set_pos()

void term_set_pos	(	term_t *	pt,
		uint8_t	col,
		uint8_t	row
	)

                                                        {
    if (!pt || !(pt->buff))
        return;
    if (col >= pt->cols)
        col = pt->cols - 1;
    if (row >= pt->rows)
        row = pt->rows - 1;
    pt->col = col;
    pt->row = row;
}

term_write_char()

void term_write_char	(	term_t *	pt,
		uint8_t	ch
	)

                                             {
    if (!pt || !(pt->buff))
        return;
    if ((ch == 0x1b) || (pt->flg & TERM_FLG_ESCAPE))
        term_write_escape_char(pt, ch);
    else if (ch < 32)
        term_write_control_char(pt, ch);
    else {
        int i = pt->col + pt->row * pt->cols;
        pt->buff[2 * i + 0] = ch;
        pt->buff[2 * i + 1] = pt->attr;
        pt->buff[pt->size + (i >> 3)] |= (1 << (i % 8));
        if (++(pt->col) >= pt->cols) {
            pt->col = 0;
            if (++(pt->row) >= pt->rows)
                term_scroll_up(pt);
        }
        pt->flg |= TERM_FLG_CHANGED;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

term_printf()

int term_printf	(	term_t *	pt,
		const char *	fmt,
			...
	)

                                                  {
    int ret;
 
    va_list va;
    va_start(va, fmt);
 
    ret = vterm_printf(pt, fmt, va);
    va_end(va);
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vterm_printf()

int vterm_printf	(	term_t *	pt,
		const char *	fmt,
		va_list	va
	)

                                                          {
    char text[TERM_PRINTF_MAX];
    int ret;
    int i;
 
    ret = vsnprintf(text, sizeof(text), fmt, va);
 
    for (i = 0; i < ret; i++)
        term_write_char(pt, text[i]);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function: