uint8_t countsurroundingalive(field_t pf, coord_t x, coord_t y) {
#define P 1u
#define NX (XSIZE - 1u) /* emulated horizontal -1 */
#define NY (YSIZE - 1u) /* emulated vertical -1 */
#if XSIZE == YSIZE
static coord_t const offset[] = {NX, NX, 0, P, P, P, 0, NX, NX, NX};
#else
static coord_t const xoffset[] = {0, P, P, P, 0, NX, NX, NX};
static coord_t const yoffset[] = {NY, NY, 0, P, P, P, 0, NY};
#endif
uint8_t i, ret = 0;
for (i = 8; i--;) {
// getcell(...) returns either 0 or 1
#if XSIZE == YSIZE
ret += getcell(pf, (coord_t)(x + offset[i+2u]) % XSIZE,
(coord_t)(y + offset[i]) % YSIZE);
#else
ret += getcell(pf, (coord_t)(x + xoffset[i]) % XSIZE,
(coord_t)(y + yoffset[i]) % YSIZE);
#endif
}
return ret;
}
int vterm_screen_get_attrs_extent(const VTermScreen *screen, VTermRect *extent, VTermPos pos, VTermAttrMask attrs)
{
int col;
ScreenCell *target = getcell(screen, pos.row, pos.col);
/* TODO: bounds check */
extent->start_row = pos.row;
extent->end_row = pos.row + 1;
if(extent->start_col < 0)
extent->start_col = 0;
if(extent->end_col < 0)
extent->end_col = screen->cols;
for(col = pos.col - 1; col >= extent->start_col; col--)
if(attrs_differ(attrs, target, getcell(screen, pos.row, col)))
break;
extent->start_col = col + 1;
for(col = pos.col + 1; col < extent->end_col; col++)
if(attrs_differ(attrs, target, getcell(screen, pos.row, col)))
break;
extent->end_col = col - 1;
return 1;
}
/* static because it's only used internally for sb_popline during resize */
static int vterm_screen_set_cell(VTermScreen *screen, VTermPos pos, const VTermScreenCell *cell)
{
ScreenCell *intcell = getcell(screen, pos.row, pos.col);
int i;
if(!intcell)
return 0;
for(i = 0; ; i++) {
intcell->chars[i] = cell->chars[i];
if(!cell->chars[i])
break;
}
intcell->pen.bold = cell->attrs.bold;
intcell->pen.underline = cell->attrs.underline;
intcell->pen.italic = cell->attrs.italic;
intcell->pen.blink = cell->attrs.blink;
intcell->pen.reverse = cell->attrs.reverse ^ screen->global_reverse;
intcell->pen.strike = cell->attrs.strike;
intcell->pen.font = cell->attrs.font;
intcell->pen.fg = cell->fg;
intcell->pen.bg = cell->bg;
if(cell->width == 2)
getcell(screen, pos.row, pos.col + 1)->chars[0] = (uint32_t)-1;
return 1;
}
static int putglyph(VTermGlyphInfo *info, VTermPos pos, void *user)
{
int i;
int col;
VTermRect rect;
VTermScreen *screen = user;
ScreenCell *cell = getcell(screen, pos.row, pos.col);
if(!cell)
return 0;
for(i = 0; i < VTERM_MAX_CHARS_PER_CELL && info->chars[i]; i++) {
cell->chars[i] = info->chars[i];
cell->pen = screen->pen;
}
if(i < VTERM_MAX_CHARS_PER_CELL)
cell->chars[i] = 0;
for(col = 1; col < info->width; col++)
getcell(screen, pos.row, pos.col + col)->chars[0] = (uint32_t)-1;
rect.start_row = pos.row;
rect.end_row = pos.row+1;
rect.start_col = pos.col;
rect.end_col = pos.col+info->width;
cell->pen.protected_cell = info->protected_cell;
cell->pen.dwl = info->dwl;
cell->pen.dhl = info->dhl;
damagerect(screen, rect);
return 1;
}
void formatcells(void)
/* Prompts the user for a selected format and range of cells */
{
int col, row, col1, col2, row1, row2, temp, newformat = 0;
writeprompt(MSGCELL1);
if (!getcell(&col1, &row1))
return;
writeprompt(MSGCELL2);
if (!getcell(&col2, &row2))
return;
if ((col1 != col2) && (row1 != row2))
errormsg(MSGDIFFCOLROW);
else
{
if (col1 > col2)
swap(&col1, &col2);
if (row1 > row2)
swap(&row1, &row2);
if (!getyesno(&temp, MSGRIGHTJUST))
return;
newformat += (temp == 'Y') * RJUSTIFY;
if (!getyesno(&temp, MSGDOLLAR))
return;
newformat += (temp == 'Y') * DOLLAR;
if (!getyesno(&temp, MSGCOMMAS))
return;
newformat += (temp == 'Y') * COMMAS;
if (newformat & DOLLAR)
newformat += 2;
else
{
writeprompt(MSGPLACES);
if (!getint(&temp, 0, MAXPLACES))
return;
newformat += temp;
}
for (col = col1; col <= col2; col++)
{
for (row = row1; row <= row2; row++)
{
format[col][row] = (format[col][row] & OVERWRITE) | newformat;
if ((col >= leftcol) && (col <= rightcol) &&
(row >= toprow) && (row <= bottomrow))
displaycell(col, row, NOHIGHLIGHT, NOUPDATE);
}
}
}
changed = TRUE;
} /* formatcells */
static int setlineinfo(int row, const VTermLineInfo *newinfo, const VTermLineInfo *oldinfo, void *user)
{
VTermScreen *screen = user;
int col;
VTermRect rect;
if(newinfo->doublewidth != oldinfo->doublewidth ||
newinfo->doubleheight != oldinfo->doubleheight) {
for(col = 0; col < screen->cols; col++) {
ScreenCell *cell = getcell(screen, row, col);
cell->pen.dwl = newinfo->doublewidth;
cell->pen.dhl = newinfo->doubleheight;
}
rect.start_row = row;
rect.end_row = row + 1;
rect.start_col = 0;
rect.end_col = newinfo->doublewidth ? screen->cols / 2 : screen->cols;
damagerect(screen, rect);
if(newinfo->doublewidth) {
rect.start_col = screen->cols / 2;
rect.end_col = screen->cols;
erase_internal(rect, 0, user);
}
}
return 1;
}
void pfprint(field_t pf) {
coord_t x,y;
for(y=YSIZE; y--;) {
for(x=XSIZE; x--;) {
setpixel((pixel){x,y},getcell(pf,x,y)*3);
}
}
}
uint8_t pfempty(field_t src) {
coord_t x,y;
for(y=YSIZE; y--;) {
for(x=XSIZE; x--;) {
if (getcell(src, x, y)==alive)
return 0;
}
}
return 1;
}
static int moverect_internal(VTermRect dest, VTermRect src, void *user)
{
VTermScreen *screen = user;
if(screen->callbacks && screen->callbacks->sb_pushline &&
dest.start_row == 0 && dest.start_col == 0 && /* starts top-left corner */
dest.end_col == screen->cols && /* full width */
screen->buffer == screen->buffers[0]) { /* not altscreen */
VTermPos pos;
for(pos.row = 0; pos.row < src.start_row; pos.row++) {
for(pos.col = 0; pos.col < screen->cols; pos.col++)
vterm_screen_get_cell(screen, pos, screen->sb_buffer + pos.col);
(screen->callbacks->sb_pushline)(screen->cols, screen->sb_buffer, screen->cbdata);
}
}
{
int cols = src.end_col - src.start_col;
int downward = src.start_row - dest.start_row;
int init_row, test_row, inc_row;
int row;
if(downward < 0) {
init_row = dest.end_row - 1;
test_row = dest.start_row - 1;
inc_row = -1;
}
else {
init_row = dest.start_row;
test_row = dest.end_row;
inc_row = +1;
}
for(row = init_row; row != test_row; row += inc_row)
memmove(getcell(screen, row, dest.start_col),
getcell(screen, row + downward, src.start_col),
cols * sizeof(ScreenCell));
}
return 1;
}
int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos)
{
/* This cell is EOL if this and every cell to the right is black */
for(; pos.col < screen->cols; pos.col++) {
ScreenCell *cell = getcell(screen, pos.row, pos.col);
if(cell->chars[0] != 0)
return 0;
}
return 1;
}
void Board::drawCell(int cx, int cy)
{
Cell *cell = getcell(cx, cy);
GLubyte cols[] = { 0, 0, 0 };
getColorByCode(cell->color, cols, cell->state);
glColor3ubv(cols);
glVertex2f(cx, cy);
glVertex2f(cx + 1.0f, cy);
glVertex2f(cx + 1.0f, cy + 1.0f);
glVertex2f(cx, cy + 1.0f);
}
// パスを読み込み
void HERE::loadPaths( string _path )
{
HERE::m_path.clear();
ifstream ifs( _path );
//1行分のバッファ
string line;
//最初の１行は捨てる
getline( ifs, line );
int lineCount = -1;
while( ifs && getline( ifs, line ) ){
lineCount++;
vector<string> cells;
HERE::cutLine( line, cells );
int i=0;
if( cells.size() <= 1 ){
continue;
}
string ailias = getcell(i++,cells);
string path = getcell(i++,cells);
INSERT( HERE::m_path, ailias, path );
}
}
void gotocell()
/* Moves to a selected cell */
{
writeprompt(MSGGOTO);
if (!getcell(&curcol, &currow))
return;
leftcol = curcol;
toprow = currow;
setbottomrow();
setrightcol();
setleftcol();
displayscreen(NOUPDATE);
} /* gotocell */
static size_t _get_chars(const VTermScreen *screen, const int utf8, void *buffer, size_t len, const VTermRect rect)
{
size_t outpos = 0;
int padding = 0;
int row, col;
#define PUT(c) \
if(utf8) { \
size_t thislen = utf8_seqlen(c); \
if(buffer && outpos + thislen <= len) \
outpos += fill_utf8((c), (char *)buffer + outpos); \
else \
outpos += thislen; \
} \
else { \
if(buffer && outpos + 1 <= len) \
((uint32_t*)buffer)[outpos++] = (c); \
else \
outpos++; \
}
for(row = rect.start_row; row < rect.end_row; row++) {
for(col = rect.start_col; col < rect.end_col; col++) {
ScreenCell *cell = getcell(screen, row, col);
int i;
if(cell->chars[0] == 0)
/* Erased cell, might need a space */
padding++;
else if(cell->chars[0] == (uint32_t)-1)
/* Gap behind a double-width char, do nothing */
;
else {
while(padding) {
PUT(UNICODE_SPACE);
padding--;
}
for(i = 0; i < VTERM_MAX_CHARS_PER_CELL && cell->chars[i]; i++) {
PUT(cell->chars[i]);
}
}
}
if(row < rect.end_row - 1) {
PUT(UNICODE_LINEFEED);
padding = 0;
}
}
return outpos;
}
/* Copy internal to external representation of a screen cell */
int vterm_screen_get_cell(const VTermScreen *screen, VTermPos pos, VTermScreenCell *cell)
{
ScreenCell *intcell = getcell(screen, pos.row, pos.col);
int i;
if(!intcell)
return 0;
for(i = 0; ; i++) {
cell->chars[i] = intcell->chars[i];
if(!intcell->chars[i])
break;
}
cell->attrs.bold = intcell->pen.bold;
cell->attrs.underline = intcell->pen.underline;
cell->attrs.italic = intcell->pen.italic;
cell->attrs.blink = intcell->pen.blink;
cell->attrs.reverse = intcell->pen.reverse ^ screen->global_reverse;
cell->attrs.strike = intcell->pen.strike;
cell->attrs.font = intcell->pen.font;
cell->attrs.dwl = intcell->pen.dwl;
cell->attrs.dhl = intcell->pen.dhl;
cell->fg = intcell->pen.fg;
cell->bg = intcell->pen.bg;
if(pos.col < (screen->cols - 1) &&
getcell(screen, pos.row, pos.col + 1)->chars[0] == (uint32_t)-1)
cell->width = 2;
else
cell->width = 1;
return 1;
}
static int erase_internal(VTermRect rect, int selective, void *user)
{
VTermScreen *screen = user;
int row, col;
for(row = rect.start_row; row < screen->state->rows && row < rect.end_row; row++) {
const VTermLineInfo *info = vterm_state_get_lineinfo(screen->state, row);
for(col = rect.start_col; col < rect.end_col; col++) {
ScreenCell *cell = getcell(screen, row, col);
if(selective && cell->pen.protected_cell)
continue;
cell->chars[0] = 0;
cell->pen = screen->pen;
cell->pen.dwl = info->doublewidth;
cell->pen.dhl = info->doubleheight;
}
}
return 1;
}
