708 lines
17 KiB
C
708 lines
17 KiB
C
/*
|
||
* Copyright (c) 1995
|
||
* Paul Richards. All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions
|
||
* are met:
|
||
* 1. Redistributions of source code must retain the above copyright
|
||
* notice, this list of conditions and the following disclaimer,
|
||
* verbatim and that no modifications are made prior to this
|
||
* point in the file.
|
||
* 2. Redistributions in binary form must reproduce the above copyright
|
||
* notice, this list of conditions and the following disclaimer in the
|
||
* documentation and/or other materials provided with the distribution.
|
||
* 3. All advertising materials mentioning features or use of this software
|
||
* must display the following acknowledgement:
|
||
* This product includes software developed by Paul Richards.
|
||
* 4. The name Paul Richards may not be used to endorse or promote products
|
||
* derived from this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND
|
||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL PAUL RICHARDS BE LIABLE
|
||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||
* SUCH DAMAGE.
|
||
*
|
||
*/
|
||
|
||
/*
|
||
* Low level ncurses support routines.
|
||
*/
|
||
|
||
#include <forms.h>
|
||
#include <ncurses.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <ttyent.h>
|
||
|
||
#include "internal.h"
|
||
|
||
/* ncurses key mappings */
|
||
/* XXX -- need to look at implementing key mapping properly */
|
||
#define K_UPL KEY_UP
|
||
#define K_DOWNL KEY_DOWN
|
||
#define K_RIGHTL 9
|
||
#define K_LEFTL 8
|
||
#define K_NEXTL 10
|
||
#define K_LEFT KEY_LEFT
|
||
#define K_RIGHT KEY_RIGHT
|
||
#define K_HOME KEY_HOME
|
||
#define K_END KEY_END
|
||
#define K_BS 263
|
||
#define K_DEL 330
|
||
#define K_ACCEPT K_NEXTL
|
||
|
||
/* Function declarations */
|
||
DISPLAY *ncurses_open(DISPLAY *);
|
||
void ncurses_moveto(OBJECT *);
|
||
int ncurses_print_srtring(OBJECT *, char *);
|
||
|
||
extern OBJECT *cur_obj;
|
||
|
||
DISPLAY *
|
||
ncurses_open(DISPLAY *display)
|
||
{
|
||
struct ttyent *tty;
|
||
NCURSDEV *device = display->device.ncurses;
|
||
FILE *in, *out;
|
||
|
||
if (device) {
|
||
tty = getttynam(device->ttyname);
|
||
if (!tty)
|
||
return (0);
|
||
|
||
in = fopen(device->input, "r");
|
||
out = fopen(device->output, "w+");
|
||
if ((!in) || (!out))
|
||
return (0);
|
||
device->screen = newterm(tty->ty_type, in, out);
|
||
} else {
|
||
display->device.ncurses = malloc(sizeof (NCURSDEV));
|
||
device = display->device.ncurses;
|
||
if (!device)
|
||
return (0);
|
||
device->screen = newterm(getenv("TERM"), stdout, stdin);
|
||
}
|
||
|
||
if (!device->screen)
|
||
return (0);
|
||
|
||
start_color();
|
||
cbreak();
|
||
noecho();
|
||
|
||
/* If we got here by default, set device type to ncurses */
|
||
if (display->type == DT_ANY)
|
||
display->type = DT_NCURSES;
|
||
|
||
|
||
display->height = LINES;
|
||
display->width = COLS;
|
||
|
||
return (display);
|
||
}
|
||
|
||
ncurses_set_display(DISPLAY *display)
|
||
{
|
||
set_term(display->device.ncurses->screen);
|
||
}
|
||
|
||
ncurses_open_window(OBJECT *object)
|
||
{
|
||
object->window.ncurses->win =
|
||
newwin(object->height, object->width, object->y, object->x);
|
||
if (!object->window.ncurses->win)
|
||
errx(-1, "Couldn't open window (%d)", lineno);
|
||
if (keypad(object->window.ncurses->win, TRUE) == ERR)
|
||
errx(-1, "Keypad call failed (%d)", lineno);
|
||
}
|
||
|
||
void
|
||
ncurses_refresh_display(DISPLAY *display)
|
||
{
|
||
doupdate();
|
||
}
|
||
|
||
/*
|
||
* Parse an attribute string. For ncurses we look up the display
|
||
* specific bindings table for the attribute strings. For ncurses
|
||
* the attribute entry is a simple integer which is passed to wattron.
|
||
*/
|
||
|
||
int
|
||
ncurses_parse_attrs(OBJECT *object, char *string)
|
||
{
|
||
hash_table *htable;
|
||
TUPLE *tuple;
|
||
int inc = 1;
|
||
char *attribute = 0;
|
||
AttrType attr_type;
|
||
int len, y, x;
|
||
int skip = 0;
|
||
|
||
if ((!string) || (*string != '\\'))
|
||
return (0);
|
||
|
||
do {
|
||
if (*(string + inc) == '\\')
|
||
return (skip);
|
||
|
||
while ((!isspace(*(string + inc)))
|
||
&& (*(string+inc) != '\\')
|
||
&& (*(string + inc) != '\0'))
|
||
inc++;
|
||
|
||
attribute = malloc(inc);
|
||
if (!attribute)
|
||
errx(-1, "Failed to allocate memory for attribute when parsing string");
|
||
strncpy(attribute, string+1, inc-1);
|
||
attribute[inc-1] = 0;
|
||
|
||
#ifdef no
|
||
/* Skip trailing space after the attribute string */
|
||
while (isspace(*(string + inc)))
|
||
inc++;
|
||
#endif
|
||
|
||
attr_type = parse_default_attributes(attribute);
|
||
free(attribute);
|
||
|
||
switch (attr_type) {
|
||
case ATTR_CENTER:
|
||
len = calc_string_width(string+inc);
|
||
getyx(object->window.ncurses->win, y, x);
|
||
wmove(object->window.ncurses->win, y,
|
||
(object->width - x - len)/2);
|
||
break;
|
||
case ATTR_RIGHT:
|
||
len = calc_string_width(string+inc);
|
||
getyx(object->window.ncurses->win, y, x);
|
||
wmove(object->window.ncurses->win, y, COLS-len);
|
||
break;
|
||
case ATTR_UNKNOWN:
|
||
default:
|
||
/*
|
||
* If no bindings table is found just skip over the attribute
|
||
* string. i.e. ignore the attribute but keep printing the text.
|
||
*/
|
||
if (object->display && object->display->bind) {
|
||
tuple = get_tuple(object->display->bind, attribute, TT_ATTR);
|
||
if (tuple)
|
||
wattron(object->window.ncurses->win, COLOR_PAIR((int)*(tuple->addr)));
|
||
}
|
||
break;
|
||
}
|
||
|
||
|
||
skip += inc;
|
||
string += inc;
|
||
inc = 0;
|
||
} while (*(string + inc++) == '\\');
|
||
|
||
return (skip);
|
||
}
|
||
|
||
int
|
||
ncurses_print_string(OBJECT *object, char *string)
|
||
{
|
||
int len, skip;
|
||
int y = object->y;
|
||
int x;
|
||
int height = object->height;
|
||
|
||
/* If it's a null string, clear the area using spaces. */
|
||
if (!string)
|
||
len = -1;
|
||
else
|
||
len = strlen(string);
|
||
|
||
wmove(object->window.ncurses->win, y, x);
|
||
|
||
while (height--) {
|
||
x = object->x;
|
||
if (wmove(object->window.ncurses->win, y++, x) == ERR)
|
||
return (ERR);
|
||
while (x++ < (object->x + object->width)) {
|
||
if (len-- > 0) {
|
||
/* Print input objects without processing \'s */
|
||
if ((*string == '\\') && (object->type != OT_INPUT)) {
|
||
skip = ncurses_parse_attrs(object, string);
|
||
len -= skip;
|
||
string += skip;
|
||
}
|
||
if (waddch(object->window.ncurses->win, *string++) == ERR)
|
||
return (ERR);
|
||
} else if (waddch(object->window.ncurses->win, ' ') == ERR)
|
||
return (ERR);
|
||
}
|
||
}
|
||
return (OK);
|
||
}
|
||
|
||
void
|
||
ncurses_display_object(OBJECT *object)
|
||
{
|
||
ncurses_set_attributes(object, 0);
|
||
|
||
switch (object->type) {
|
||
case OT_ACTION:
|
||
ncurses_display_action(object);
|
||
break;
|
||
case OT_COMPOUND:
|
||
ncurses_display_compound(object);
|
||
break;
|
||
case OT_FUNCTION:
|
||
ncurses_display_function(object);
|
||
break;
|
||
case OT_INPUT:
|
||
ncurses_display_input(object);
|
||
break;
|
||
case OT_MENU:
|
||
ncurses_display_menu(object);
|
||
break;
|
||
case OT_TEXT:
|
||
ncurses_display_text(object);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
ncurses_process_object(OBJECT *object)
|
||
{
|
||
ncurses_set_attributes(object, 1);
|
||
|
||
switch (object->type) {
|
||
case OT_ACTION:
|
||
ncurses_process_action(object);
|
||
break;
|
||
case OT_FUNCTION:
|
||
break;
|
||
case OT_INPUT:
|
||
ncurses_process_input(object);
|
||
break;
|
||
case OT_MENU:
|
||
ncurses_process_menu(object);
|
||
break;
|
||
case OT_TEXT:
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
void
|
||
ncurses_draw_box(OBJECT *object)
|
||
{
|
||
int y, x;
|
||
chtype box, border;
|
||
|
||
ncurses_parse_attrs(object, object->highlight);
|
||
wattron(object->window.ncurses->win, A_BOLD);
|
||
|
||
mvwaddch(object->window.ncurses->win, object->y, object->x,
|
||
ACS_ULCORNER);
|
||
|
||
mvwaddch(object->window.ncurses->win,
|
||
object->y + object->height - 1,
|
||
object->x,
|
||
ACS_LLCORNER);
|
||
|
||
for (y=object->y + 1; y < (object->y + object->height) - 1; y++) {
|
||
mvwaddch(object->window.ncurses->win, y, object->x,
|
||
ACS_VLINE);
|
||
}
|
||
for (x=object->x + 1; x < (object->x + object->width) - 1; x++) {
|
||
mvwaddch(object->window.ncurses->win, object->y, x,
|
||
ACS_HLINE);
|
||
}
|
||
|
||
ncurses_parse_attrs(object, object->attributes);
|
||
wattroff(object->window.ncurses->win, A_BOLD);
|
||
|
||
mvwaddch(object->window.ncurses->win, object->y,
|
||
object->x + object->width-1,
|
||
ACS_URCORNER);
|
||
|
||
mvwaddch(object->window.ncurses->win,
|
||
object->y + object->height-1,
|
||
object->x + object->width-1,
|
||
ACS_LRCORNER);
|
||
|
||
for (y=object->y + 1; y < (object->y + object->height) - 1; y++) {
|
||
mvwaddch(object->window.ncurses->win, y, object->x + object->width - 1,
|
||
ACS_VLINE);
|
||
}
|
||
for (x=object->x + 1; x < (object->x + object->width) - 1; x++) {
|
||
mvwaddch(object->window.ncurses->win, object->y + object->height - 1, x,
|
||
ACS_HLINE);
|
||
}
|
||
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_draw_shadow(OBJECT *object)
|
||
{
|
||
int i;
|
||
|
||
for (i=object->y + 1; i < (object->y + object->height); i++) {
|
||
wattron(object->window.ncurses->win, A_INVIS);
|
||
mvwaddch(object->window.ncurses->win, i, object->x + object->width, ' ');
|
||
waddch(object->window.ncurses->win,
|
||
mvwinch(object->window.ncurses->win,
|
||
i, object->x + object->width) & A_CHARTEXT);
|
||
waddch(object->window.ncurses->win,
|
||
mvwinch(object->window.ncurses->win,
|
||
i, object->x + object->width+1) & A_CHARTEXT);
|
||
}
|
||
for (i=object->x + 1; i < (object->x + object->width + 2); i++) {
|
||
wattrset(object->window.ncurses->win, A_INVIS);
|
||
wmove(object->window.ncurses->win, object->y+object->height, i);
|
||
waddstr(object->window.ncurses->win, " ");
|
||
wattrset(object->window.ncurses->win, COLOR_PAIR(2)|A_BOLD);
|
||
waddch(object->window.ncurses->win,
|
||
mvwinch(object->window.ncurses->win,
|
||
object->y+object->height, i) & A_CHARTEXT);
|
||
}
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_display_compound(OBJECT *object)
|
||
{
|
||
int y, x;
|
||
|
||
for (y=object->y; y < (object->y + object->height); y++)
|
||
for (x=object->x; x < (object->x + object->width); x++)
|
||
waddch(object->window.ncurses->win,
|
||
mvwinch(object->window.ncurses->win, y, x) & A_CHARTEXT);
|
||
}
|
||
|
||
void
|
||
ncurses_display_action(OBJECT *object)
|
||
{
|
||
ncurses_print_string(object, object->object.action->text);
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_display_function(OBJECT *object)
|
||
{
|
||
TUPLE *tuple;
|
||
void (* fn)();
|
||
|
||
tuple = tuple_search(object, object->object.function->fn, TT_FUNC);
|
||
if (!tuple)
|
||
return;
|
||
fn = (FUNCP)tuple->addr;
|
||
if (fn)
|
||
(*fn)(object);
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_display_text(OBJECT *object)
|
||
{
|
||
ncurses_print_string(object, object->object.text->text);
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_display_input(OBJECT *object)
|
||
{
|
||
if (object->object.input->lbl_flag)
|
||
ncurses_print_string(object, object->object.input->label);
|
||
else
|
||
ncurses_print_string(object, object->object.input->input);
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_process_action(OBJECT *object)
|
||
{
|
||
TUPLE *tuple;
|
||
int ch;
|
||
|
||
ncurses_display_action(object);
|
||
wmove(object->window.ncurses->win, object->y, object->x);
|
||
|
||
for (;;) {
|
||
ch = wgetch(object->window.ncurses->win);
|
||
|
||
if (ch == K_ACCEPT) {
|
||
tuple = tuple_search(object,
|
||
object->object.action->action, TT_FUNC);
|
||
|
||
if (!tuple) {
|
||
ncurses_print_status("No function bound to action");
|
||
continue;
|
||
} else {
|
||
(*tuple->addr)(object);
|
||
return;
|
||
}
|
||
} else {
|
||
ch = ncurses_bind_key(object, ch);
|
||
|
||
if (ch == ST_ERROR) {
|
||
beep();
|
||
continue;
|
||
} else
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
void
|
||
ncurses_process_input(OBJECT *object)
|
||
{
|
||
int len;
|
||
int disp_off=0, abspos=0, cursor = 0;
|
||
int ch;
|
||
|
||
#define DISPOFF ((len < object->width) ? 0 : len - object->width)
|
||
#define CURSPOS ((len < object->width) ? len : object->width)
|
||
|
||
ncurses_display_input(object);
|
||
|
||
len = strlen(object->object.input->input);
|
||
|
||
cursor = CURSPOS;
|
||
abspos = cursor;
|
||
|
||
for (;;) {
|
||
|
||
wmove(object->window.ncurses->win, object->y, object->x+cursor);
|
||
|
||
ch = wgetch(object->window.ncurses->win);
|
||
ch = ncurses_bind_key(object, ch);
|
||
|
||
/*
|
||
* If there was a valid motion command then we've
|
||
* moved to a new object so just return. If the motion
|
||
* command was invalid then just go around and get another
|
||
* keystroke. Otherwise, it was not a motion command.
|
||
*/
|
||
|
||
if (ch == ST_OK)
|
||
return;
|
||
else if (ch == ST_ERROR)
|
||
continue;
|
||
|
||
ncurses_print_status("");
|
||
|
||
if (object->object.input->lbl_flag) {
|
||
object->object.input->lbl_flag = 0;
|
||
}
|
||
if ((ch == K_HOME) || (ch == '')) {
|
||
disp_off = 0;
|
||
cursor = 0;
|
||
abspos = 0;
|
||
} else if ((ch == K_END) || (ch == '')) {
|
||
disp_off = DISPOFF;
|
||
abspos = len;
|
||
cursor = CURSPOS;
|
||
} else if (ch == K_DEL) {
|
||
if (!(len-abspos))
|
||
beep();
|
||
else {
|
||
bcopy(object->object.input->input+abspos+1,
|
||
object->object.input->input+abspos,
|
||
len - abspos);
|
||
--len;
|
||
}
|
||
} else if ((ch == K_LEFT) || (ch == K_BS) || (ch == '')) {
|
||
if (!abspos)
|
||
beep();
|
||
else {
|
||
if (ch == K_BS) {
|
||
bcopy(object->object.input->input+abspos,
|
||
object->object.input->input+abspos-1,
|
||
len-abspos+1);
|
||
--len;
|
||
}
|
||
--abspos;
|
||
--cursor;
|
||
if ((disp_off) && (cursor < 0)) {
|
||
--disp_off;
|
||
++cursor;
|
||
}
|
||
}
|
||
}else if (ch == '') {
|
||
bzero(object->object.input->input, len);
|
||
len = 0;
|
||
abspos = 0;
|
||
cursor = 0;
|
||
disp_off = 0;
|
||
} else if ((ch == K_RIGHT) || (ch == '')) {
|
||
if (abspos == len)
|
||
beep();
|
||
else {
|
||
++abspos;
|
||
if (++cursor >= object->width) {
|
||
++disp_off;
|
||
--cursor;
|
||
}
|
||
}
|
||
} else if ((isprint(ch)) && (len < object->object.input->limit)){
|
||
bcopy(object->object.input->input+abspos,
|
||
object->object.input->input+abspos+1, len-abspos+1);
|
||
object->object.input->input[abspos++] = ch;
|
||
len++;
|
||
if (++cursor > object->width) {
|
||
++disp_off;
|
||
--cursor;
|
||
}
|
||
} else
|
||
beep();
|
||
ncurses_print_string(object, object->object.input->input+disp_off);
|
||
}
|
||
}
|
||
|
||
void
|
||
ncurses_print_status(char *msg)
|
||
{
|
||
if (wmove(stdscr, LINES-1, 0) == ERR) {
|
||
endwin();
|
||
exit(1);
|
||
}
|
||
|
||
wclrtoeol(stdscr);
|
||
|
||
wstandout(stdscr);
|
||
if (wprintw(stdscr, "%s",
|
||
msg) == ERR) {
|
||
endwin();
|
||
exit(1);
|
||
}
|
||
wstandend(stdscr);
|
||
wrefresh(stdscr);
|
||
}
|
||
|
||
int
|
||
ncurses_bind_key(OBJECT *object, unsigned int ch)
|
||
{
|
||
struct Tuple *tuple=0;
|
||
|
||
/* XXX -- check for keymappings here --- not yet done */
|
||
|
||
if (ch == K_UPL) {
|
||
if (object->lup) {
|
||
tuple = tuple_search(object, object->lup, TT_OBJ_INST);
|
||
if (!tuple)
|
||
ncurses_print_status("Field to move up to does not exist");
|
||
} else
|
||
ncurses_print_status("Can't move up from this object");
|
||
} else if (ch == K_DOWNL) {
|
||
if (object->ldown) {
|
||
tuple = tuple_search(object, object->ldown, TT_OBJ_INST);
|
||
if (!tuple)
|
||
ncurses_print_status("Field to move down to does not exist");
|
||
} else
|
||
ncurses_print_status("Can't move down from this object");
|
||
} else if (ch == K_LEFTL) {
|
||
if (object->lleft) {
|
||
tuple = tuple_search(object, object->lleft, TT_OBJ_INST);
|
||
if (!tuple)
|
||
ncurses_print_status("Field to move left to does not exist");
|
||
} else
|
||
ncurses_print_status("Can't move left from this object");
|
||
} else if (ch == K_RIGHTL) {
|
||
if (object->lright) {
|
||
tuple = tuple_search(object, object->lright, TT_OBJ_INST);
|
||
if (!tuple)
|
||
ncurses_print_status("Field to move right to does not exist");
|
||
} else
|
||
ncurses_print_status("Can't move right from this object");
|
||
} else if (ch == K_NEXTL) {
|
||
if (object->lnext) {
|
||
tuple = tuple_search(object, object->lnext, TT_OBJ_INST);
|
||
if (!tuple)
|
||
ncurses_print_status("Field to move to next does not exist");
|
||
} else
|
||
ncurses_print_status("There is no next object from this object");
|
||
} else
|
||
/* No motion keys pressed */
|
||
return (ch);
|
||
|
||
if (tuple) {
|
||
cur_obj = (OBJECT *)tuple->addr;
|
||
return (ST_OK);
|
||
} else {
|
||
beep();
|
||
return (ST_ERROR);
|
||
}
|
||
}
|
||
|
||
void
|
||
ncurses_display_menu(OBJECT *object)
|
||
{
|
||
if (ncurses_print_string(object,
|
||
object->object.menu->options[object->object.menu->selected]) == ERR)
|
||
ncurses_print_status("Illegal scroll in print_string");
|
||
wnoutrefresh(object->window.ncurses->win);
|
||
}
|
||
|
||
void
|
||
ncurses_process_menu(OBJECT *object)
|
||
{
|
||
int ch;
|
||
|
||
for (;;) {
|
||
|
||
ncurses_display_menu(object);
|
||
wmove(object->window.ncurses->win, object->y, object->x);
|
||
|
||
ch = wgetch(object->window.ncurses->win);
|
||
|
||
switch (ch) {
|
||
case ' ':
|
||
ncurses_print_status("");
|
||
object->object.menu->selected++;
|
||
if (object->object.menu->selected >= object->object.menu->no_options)
|
||
object->object.menu->selected = 0;
|
||
ch = ST_OK;
|
||
break;
|
||
default:
|
||
ch = ncurses_bind_key(object, ch);
|
||
break;
|
||
}
|
||
|
||
if (ch == ST_OK)
|
||
return;
|
||
else if (ch == ST_ERROR) {
|
||
beep();
|
||
continue;
|
||
} else {
|
||
ncurses_print_status("Hit the space bar to toggle through options");
|
||
beep();
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
ncurses_set_attributes(OBJECT *object, int hl)
|
||
{
|
||
int y, x;
|
||
char *attr = 0;
|
||
|
||
if (hl && object->highlight)
|
||
attr = object->highlight;
|
||
else if (object->attributes)
|
||
attr = object->attributes;
|
||
if (attr) {
|
||
wattrset(object->window.ncurses->win, A_NORMAL);
|
||
ncurses_parse_attrs(object, attr);
|
||
}
|
||
}
|