/* * This creates a new CDK screen. */ CDKSCREEN *initCDKScreen (WINDOW *window) { ALL_SCREENS *item; CDKSCREEN *screen = 0; /* initialization, for the first time */ if (all_screens == 0) { /* Set up basic curses settings. */ #ifdef HAVE_SETLOCALE setlocale (LC_ALL, ""); #endif noecho (); cbreak (); } if ((item = typeMalloc (ALL_SCREENS)) != 0) { if ((screen = typeCalloc (CDKSCREEN)) != 0) { item->link = all_screens; item->screen = screen; all_screens = item; /* Initialize the CDKSCREEN pointer. */ screen->objectCount = 0; screen->objectLimit = 2; screen->object = typeMallocN (CDKOBJS *, screen->objectLimit); screen->window = window; /* OK, we are done. */ } else {
NCURSES_SP_NAME(newpad) (NCURSES_SP_DCLx int l, int c) { WINDOW *win; NCURSES_CH_T *ptr; int i; T((T_CALLED("newpad(%p,%d, %d)"), (void *) SP_PARM, l, c)); if (l <= 0 || c <= 0) returnWin(0); win = NCURSES_SP_NAME(_nc_makenew) (NCURSES_SP_ARGx l, c, 0, 0, _ISPAD); if (win == NULL) returnWin(0); for (i = 0; i < l; i++) { if_USE_SCROLL_HINTS(win->_line[i].oldindex = _NEWINDEX); if ((win->_line[i].text = typeCalloc(NCURSES_CH_T, ((size_t) c))) == 0) { (void) _nc_freewin(win); returnWin(0); } for (ptr = win->_line[i].text; ptr < win->_line[i].text + c; ptr++) SetChar(*ptr, BLANK_TEXT, BLANK_ATTR); } returnWin(win); }
static COUNTS * chrcount(char *path) { char temp[1024]; char leaf[1024]; size_t used = 0; size_t need = 2; COUNTS *result = typeCalloc(need, COUNTS); if (isdirectory(path)) { FILE *pp = popen("ls -1 -a", "r"); if (pp != 0) { while (fgets(leaf, sizeof(leaf), pp) != 0) { trim(leaf); sprintf(temp, "%s/%s", path, leaf); if ((used + 1) >= need) { need = (used + 1) * 2; result = realloc(result, sizeof(COUNTS) * need); } if ((result[used].count = do_count(temp)) >= 0) { result[used].name = strmalloc(leaf); used++; result[used].name = 0; } } pclose(pp); } } else { result[0].name = strmalloc(path); result[0].count = do_count(path); } return result; }
_nc_acs_map(void) { static chtype *the_map = 0; if (the_map == 0) the_map = typeCalloc(chtype, ACS_LEN); return the_map; }
static CARD * add_title(const char *title) { CARD *card, *p, *q; for (p = all_cards, q = 0; p != 0; q = p, p = p->link) { int cmp = strcmp(p->title, title); if (cmp == 0) return p; if (cmp > 0) break; } card = typeCalloc(CARD, 1); card->title = strdup(title); card->content = strdup(""); if (q == 0) { card->link = all_cards; all_cards = card; } else { card->link = q->link; q->link = card; } return card; }
static TTY * saved_tty(NCURSES_SP_DCL0) { TTY *result = 0; if (SP_PARM != 0) { result = (TTY *) & (SP_PARM->_saved_tty); } else { if (_nc_prescreen.saved_tty == 0) { _nc_prescreen.saved_tty = typeCalloc(TTY, 1); } result = _nc_prescreen.saved_tty; } return result; }
/* * Define each field with an extra one, for reflecting "actual" text. */ static FIELD * make_field(int frow, int fcol, int rows, int cols) { FIELD *f = new_field(rows, cols, frow, fcol, o_value, 1); if (f) { FieldAttrs *ptr; set_field_back(f, A_UNDERLINE); /* * If -j and -d options are combined, -j loses. It is documented in * "Character User Interface Programming", page 12-15 that setting * O_STATIC off makes the form library ignore justification. */ set_field_just(f, j_value); if (d_option) { if (has_colors()) { set_field_fore(f, (chtype) COLOR_PAIR(2)); set_field_back(f, A_UNDERLINE | COLOR_PAIR(3)); } else { set_field_fore(f, A_BOLD); } /* * The field_opts_off() call dumps core with Solaris curses, * but that is a known bug in Solaris' form library -TD */ field_opts_off(f, O_STATIC); set_max_field(f, m_value); } /* * The userptr is used in edit_field.c's inactive_field(). */ ptr = (FieldAttrs *) field_userptr(f); if (ptr == 0) { ptr = typeCalloc(FieldAttrs, 1); ptr->background = field_back(f); } set_field_userptr(f, (void *) ptr); if (t_value) set_field_buffer(f, 0, t_value); } return (f); }
static MYDATA * initialize(const char *name, FILE *output) { MYDATA *result = typeCalloc(MYDATA, 1); int error; result->fp = output; result->name = name; result->outc = (fileno(output) == 1) ? my_outc : my_errc; result->sp = opt_n ? NULL : new_prescr(); if (opt_t) { char *temp = strdup(name); tgetent_sp(result->sp, temp, name); free(temp); } else { setupterm((NCURSES_CONST char *) name, fileno(output), &error); } result->term = cur_term; return result; }
/* * Create a new object beginning with a CDKOBJS struct. The whole object is * initialized to zeroes except for special cases which have known values. */ void *_newCDKObject (unsigned size, const CDKFUNCS * funcs) { ALL_OBJECTS *item; CDKOBJS *result = 0; if ((item = typeCalloc (ALL_OBJECTS)) != 0) { if ((result = (CDKOBJS *)calloc (1, size)) != 0) { result->fn = funcs; result->hasFocus = TRUE; result->isVisible = TRUE; item->link = all_objects; item->object = result; all_objects = item; /* set default line-drawing characters */ result->ULChar = ACS_ULCORNER; result->URChar = ACS_URCORNER; result->LLChar = ACS_LLCORNER; result->LRChar = ACS_LRCORNER; result->HZChar = ACS_HLINE; result->VTChar = ACS_VLINE; result->BXAttr = A_NORMAL; /* set default exit-types */ result->exitType = vNEVER_ACTIVATED; result->earlyExit = vNEVER_ACTIVATED; } else { free (item); } } return (void *)result; }
_nc_add_to_try(TRIES ** tree, const char *str, unsigned code) { TRIES *ptr, *savedptr; unsigned const char *txt = (unsigned const char *) str; T((T_CALLED("_nc_add_to_try(%p, %s, %u)"), *tree, _nc_visbuf(str), code)); if (txt == 0 || *txt == '\0' || code == 0) returnCode(ERR); if ((*tree) != 0) { ptr = savedptr = (*tree); for (;;) { unsigned char cmp = *txt; while (!CMP_TRY(ptr->ch, cmp) && ptr->sibling != 0) ptr = ptr->sibling; if (CMP_TRY(ptr->ch, cmp)) { if (*(++txt) == '\0') { ptr->value = code; returnCode(OK); } if (ptr->child != 0) ptr = ptr->child; else break; } else { if ((ptr->sibling = typeCalloc(TRIES, 1)) == 0) { returnCode(ERR); } savedptr = ptr = ptr->sibling; SET_TRY(ptr, txt); ptr->value = 0; break; } } /* end for (;;) */ } else { /* (*tree) == 0 :: First sequence to be added */ savedptr = ptr = (*tree) = typeCalloc(TRIES, 1); if (ptr == 0) { returnCode(ERR); } SET_TRY(ptr, txt); ptr->value = 0; } /* at this point, we are adding to the try. ptr->child == 0 */ while (*txt) { ptr->child = typeCalloc(TRIES, 1); ptr = ptr->child; if (ptr == 0) { while ((ptr = savedptr) != 0) { savedptr = ptr->child; free(ptr); } returnCode(ERR); } SET_TRY(ptr, txt); ptr->value = 0; } ptr->value = code; returnCode(OK); }
NCURSES_PUBLIC_VAR(acs_map) (void) { if (MyBuffer == 0) MyBuffer = typeCalloc(chtype, ACS_LEN); return MyBuffer; }
_nc_init_wacs(void) { /* *INDENT-OFF* */ static const struct { int map; int value[2]; } table[] = { /* VT100 symbols */ { 'l', { '+', 0x250c }}, /* upper left corner */ { 'm', { '+', 0x2514 }}, /* lower left corner */ { 'k', { '+', 0x2510 }}, /* upper right corner */ { 'j', { '+', 0x2518 }}, /* lower right corner */ { 't', { '+', 0x251c }}, /* tee pointing left */ { 'u', { '+', 0x2524 }}, /* tee pointing right */ { 'v', { '+', 0x2534 }}, /* tee pointing up */ { 'w', { '+', 0x252c }}, /* tee pointing down */ { 'q', { '-', 0x2500 }}, /* horizontal line */ { 'x', { '|', 0x2502 }}, /* vertical line */ { 'n', { '+', 0x253c }}, /* large plus or crossover */ { 'o', { '~', 0x23ba }}, /* scan line 1 */ { 's', { '_', 0x23bd }}, /* scan line 9 */ { '`', { '+', 0x25c6 }}, /* diamond */ { 'a', { ':', 0x2592 }}, /* checker board (stipple) */ { 'f', { '\'', 0x00b0 }}, /* degree symbol */ { 'g', { '#', 0x00b1 }}, /* plus/minus */ { '~', { 'o', 0x00b7 }}, /* bullet */ /* Teletype 5410v1 symbols */ { ',', { '<', 0x2190 }}, /* arrow pointing left */ { '+', { '>', 0x2192 }}, /* arrow pointing right */ { '.', { 'v', 0x2193 }}, /* arrow pointing down */ { '-', { '^', 0x2191 }}, /* arrow pointing up */ { 'h', { '#', 0x2592 }}, /* board of squares */ { 'i', { '#', 0x2603 }}, /* lantern symbol */ { '0', { '#', 0x25ae }}, /* solid square block */ /* these defaults were invented for ncurses */ { 'p', { '-', 0x23bb }}, /* scan line 3 */ { 'r', { '-', 0x23bc }}, /* scan line 7 */ { 'y', { '<', 0x2264 }}, /* less-than-or-equal-to */ { 'z', { '>', 0x2265 }}, /* greater-than-or-equal-to */ { '{', { '*', 0x03c0 }}, /* greek pi */ { '|', { '!', 0x2260 }}, /* not-equal */ { '}', { 'f', 0x00a3 }}, /* pound-sterling symbol */ }; /* *INDENT-ON* */ unsigned n, m; int active = _nc_unicode_locale(); /* * If we're running in a UTF-8 locale, will use the Unicode equivalents * rather than the terminfo information. Actually the terminfo should * be the rule, but there are people who are offended by the notion that * a Unicode-capable terminal would have something resembling a mode. * So the smacs/rmacs may be disabled -- sometime. */ T(("initializing WIDE-ACS map (Unicode is%s active)", active ? "" : " not")); _nc_wacs = typeCalloc(cchar_t, ACS_LEN); for (n = 0; n < SIZEOF(table); ++n) { int wide = wcwidth(table[n].value[active]); m = table[n].map; if (active && (wide == 1)) { SetChar(_nc_wacs[m], table[n].value[active], A_NORMAL); } else if (acs_map[m] & A_ALTCHARSET) { SetChar(_nc_wacs[m], m, A_ALTCHARSET); } else { SetChar(_nc_wacs[m], table[n].value[0], A_NORMAL); } T(("#%d, SetChar(%c, %#04x) = %s", n, m, table[n].value[active], _tracecchar_t(&_nc_wacs[m]))); } }
#if HAVE_USE_WINDOW SCREEN *sp GCC_UNUSED, #endif void *arg) { DITTO *target = (DITTO *) arg; int high, wide; int k; cbreak(); noecho(); scrollok(stdscr, TRUE); box(stdscr, 0, 0); target->windows = typeCalloc(WINDOW *, (size_t) target->length); target->peeks = typeCalloc(PEEK, (size_t) target->length); high = (LINES - 2) / target->length; wide = (COLS - 2); for (k = 0; k < target->length; ++k) { WINDOW *outer = newwin(high, wide, 1 + (high * k), 1); WINDOW *inner = derwin(outer, high - 2, wide - 2, 1, 1); box(outer, 0, 0); mvwaddstr(outer, 0, 2, target->titles[k]); wnoutrefresh(outer); scrollok(inner, TRUE); keypad(inner, TRUE); #ifndef USE_PTHREADS nodelay(inner, TRUE);
_nc_alloc_screen(void) { return ((my_screen = typeCalloc(SCREEN, 1)) != 0); }
_nc_acs_map(void) { if (MyBuffer == 0) MyBuffer = typeCalloc(chtype, ACS_LEN); return MyBuffer; }
/* * Initialize soft labels. * Called from newterm() */ int _nc_slk_initialize(WINDOW *stwin, int cols) { int i, x; char *p; T(("slk_initialize()")); if (SP->_slk) { /* we did this already, so simply return */ return(OK); } else if ((SP->_slk = typeCalloc(SLK, 1)) == 0) return(ERR); SP->_slk->ent = NULL; SP->_slk->buffer = NULL; SP->_slk->attr = A_STANDOUT; #ifdef num_labels SP->_slk->maxlab = (num_labels > 0) ? num_labels : MAX_SKEY; SP->_slk->maxlen = (num_labels > 0) ? label_width * label_height : MAX_SKEY_LEN; SP->_slk->labcnt = (SP->_slk->maxlab < MAX_SKEY) ? MAX_SKEY : SP->_slk->maxlab; #else SP->_slk->labcnt = SP->_slk->maxlab = MAX_SKEY; SP->_slk->maxlen = MAX_SKEY_LEN; #endif /* num_labels */ SP->_slk->ent = typeCalloc(slk_ent, SP->_slk->labcnt); if (SP->_slk->ent == NULL) goto exception; p = SP->_slk->buffer = (char*) calloc(2*SP->_slk->labcnt,(1+SP->_slk->maxlen)); if (SP->_slk->buffer == NULL) goto exception; for (i = 0; i < SP->_slk->labcnt; i++) { SP->_slk->ent[i].text = p; p += (1 + SP->_slk->maxlen); SP->_slk->ent[i].form_text = p; p += (1 + SP->_slk->maxlen); memset(SP->_slk->ent[i].form_text, ' ', (unsigned)(SP->_slk->maxlen)); SP->_slk->ent[i].visible = (i < SP->_slk->maxlab); } if (_nc_slk_format >= 3) /* PC style */ { int gap = (cols - 3 * (3 + 4*SP->_slk->maxlen))/2; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].x = x; x += SP->_slk->maxlen; x += (i==3 || i==7) ? gap : 1; } if (_nc_slk_format == 4) slk_paint_info (stwin); } else { if (_nc_slk_format == 2) { /* 4-4 */ int gap = cols - (SP->_slk->maxlab * SP->_slk->maxlen) - 6; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].x = x; x += SP->_slk->maxlen; x += (i == 3) ? gap : 1; } } else { if (_nc_slk_format == 1) { /* 1 -> 3-2-3 */ int gap = (cols - (SP->_slk->maxlab * SP->_slk->maxlen) - 5) / 2; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].x = x; x += SP->_slk->maxlen; x += (i == 2 || i == 4) ? gap : 1; } } else goto exception; } } SP->_slk->dirty = TRUE; if ((SP->_slk->win = stwin) == NULL) { exception: if (SP->_slk) { FreeIfNeeded(SP->_slk->buffer); FreeIfNeeded(SP->_slk->ent); free(SP->_slk); SP->_slk = (SLK*)0; return(ERR); } } return(OK); }
int main(int argc, char **argv) { struct name_table_entry *name_table = typeCalloc(struct name_table_entry, CAPTABSIZE); HashValue *hash_table = typeCalloc(HashValue, HASHTABSIZE); const char *root_name = ""; int column = 0; int bigstring = 0; int n; char buffer[BUFSIZ]; static const char *typenames[] = {"BOOLEAN", "NUMBER", "STRING"}; short BoolCount = 0; short NumCount = 0; short StrCount = 0; /* The first argument is the column-number (starting with 0). * The second is the root name of the tables to generate. */ if (argc <= 3 || (column = atoi(argv[1])) <= 0 || (column >= MAX_COLUMNS) || *(root_name = argv[2]) == 0 || (bigstring = atoi(argv[3])) < 0 || name_table == 0 || hash_table == 0) { fprintf(stderr, "usage: make_hash column root_name bigstring\n"); exit(EXIT_FAILURE); } /* * Read the table into our arrays. */ for (n = 0; (n < CAPTABSIZE) && fgets(buffer, BUFSIZ, stdin);) { char **list, *nlp = strchr(buffer, '\n'); if (nlp) *nlp = '\0'; list = parse_columns(buffer); if (list == 0) /* blank or comment */ continue; if (column > count_columns(list)) { fprintf(stderr, "expected %d columns, have %d:\n%s\n", column, count_columns(list), buffer); exit(EXIT_FAILURE); } name_table[n].nte_link = -1; /* end-of-hash */ name_table[n].nte_name = strmalloc(list[column]); if (!strcmp(list[2], "bool")) { name_table[n].nte_type = BOOLEAN; name_table[n].nte_index = BoolCount++; } else if (!strcmp(list[2], "num")) { name_table[n].nte_type = NUMBER; name_table[n].nte_index = NumCount++; } else if (!strcmp(list[2], "str")) { name_table[n].nte_type = STRING; name_table[n].nte_index = StrCount++; } else { fprintf(stderr, "Unknown type: %s\n", list[2]); exit(EXIT_FAILURE); } n++; } _nc_make_hash_table(name_table, hash_table); /* * Write the compiled tables to standard output */ if (bigstring) { int len = 0; int nxt; printf("static const char %s_names_text[] = \\\n", root_name); for (n = 0; n < CAPTABSIZE; n++) { nxt = (int) strlen(name_table[n].nte_name) + 5; if (nxt + len > 72) { printf("\\\n"); len = 0; } printf("\"%s\\0\" ", name_table[n].nte_name); len += nxt; } printf(";\n\n"); len = 0; printf("static name_table_data const %s_names_data[] =\n", root_name); printf("{\n"); for (n = 0; n < CAPTABSIZE; n++) { printf("\t{ %15d,\t%10s,\t%3d, %3d }%c\n", len, typenames[name_table[n].nte_type], name_table[n].nte_index, name_table[n].nte_link, n < CAPTABSIZE - 1 ? ',' : ' '); len += (int) strlen(name_table[n].nte_name) + 1; } printf("};\n\n"); printf("static struct name_table_entry *_nc_%s_table = 0;\n\n", root_name); } else { printf("static struct name_table_entry const _nc_%s_table[] =\n", root_name); printf("{\n"); for (n = 0; n < CAPTABSIZE; n++) { _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) "\"%s\"", name_table[n].nte_name); printf("\t{ %15s,\t%10s,\t%3d, %3d }%c\n", buffer, typenames[name_table[n].nte_type], name_table[n].nte_index, name_table[n].nte_link, n < CAPTABSIZE - 1 ? ',' : ' '); } printf("};\n\n"); } printf("static const HashValue _nc_%s_hash_table[%d] =\n", root_name, HASHTABSIZE + 1); printf("{\n"); for (n = 0; n < HASHTABSIZE; n++) { printf("\t%3d,\n", hash_table[n]); } printf("\t0\t/* base-of-table */\n"); printf("};\n\n"); printf("#if (BOOLCOUNT!=%d)||(NUMCOUNT!=%d)||(STRCOUNT!=%d)\n", BoolCount, NumCount, StrCount); printf("#error\t--> term.h and comp_captab.c disagree about the <--\n"); printf("#error\t--> numbers of booleans, numbers and/or strings <--\n"); printf("#endif\n\n"); free(hash_table); return EXIT_SUCCESS; }
int setupterm(const char *tname, int Filedes, int *errret) { struct term *term_ptr; int status; T((T_CALLED("setupterm(\"%s\",%d,%p)"), tname, Filedes, errret)); if (tname == 0) { tname = getenv("TERM"); if (tname == 0 || *tname == '\0') { ret_error0(-1, "TERM environment variable not set.\n"); } } if (strlen(tname) > MAX_NAME_SIZE) { ret_error(-1, "TERM environment must be <= %d characters.\n", MAX_NAME_SIZE); } T(("your terminal name is %s", tname)); term_ptr = typeCalloc(TERMINAL, 1); if (term_ptr == 0) { ret_error0(-1, "Not enough memory to create terminal structure.\n") ; } #if USE_DATABASE status = grab_entry(tname, &term_ptr->type); #else status = 0; #endif /* try fallback list if entry on disk */ if (status != 1) { const TERMTYPE *fallback = _nc_fallback(tname); if (fallback) { memcpy(&term_ptr->type, fallback, sizeof(TERMTYPE)); status = 1; } } if (status == -1) { ret_error0(-1, "terminals database is inaccessible\n"); } else if (status == 0) { ret_error(0, "'%s': unknown terminal type.\n", tname); } set_curterm(term_ptr); if (command_character && getenv("CC")) do_prototype(); strlcpy(ttytype, cur_term->type.term_names, NAMESIZE); /* * Allow output redirection. This is what SVr3 does. * If stdout is directed to a file, screen updates go * to standard error. */ if (Filedes == STDOUT_FILENO && !isatty(Filedes)) Filedes = STDERR_FILENO; cur_term->Filedes = Filedes; _nc_get_screensize(&LINES, &COLS); if (errret) *errret = 1; T((T_CREATE("screen %s %dx%d"), tname, LINES, COLS)); if (generic_type) { ret_error(0, "'%s': I need something more specific.\n", tname); } if (hard_copy) { ret_error(1, "'%s': I can't handle hardcopy terminals.\n", tname); } returnCode(OK); }
_nc_slk_initialize(WINDOW *stwin, int cols) { int i; int res = OK; unsigned max_length; SCREEN *sp; TERMINAL *term; int numlab; T((T_CALLED("_nc_slk_initialize()"))); assert(stwin); sp = _nc_screen_of(stwin); if (0 == sp) returnCode(ERR); term = TerminalOf(SP_PARM); assert(term); numlab = NumLabels; if (SP_PARM->_slk) { /* we did this already, so simply return */ returnCode(OK); } else if ((SP_PARM->_slk = typeCalloc(SLK, 1)) == 0) returnCode(ERR); if (!SP_PARM->slk_format) SP_PARM->slk_format = _nc_globals.slk_format; /* * If we use colors, vidputs() will suppress video attributes that conflict * with colors. In that case, we're still guaranteed that "reverse" would * work. */ if ((NoColorVideo & 1) == 0) SetAttr(SP_PARM->_slk->attr, A_STANDOUT); else SetAttr(SP_PARM->_slk->attr, A_REVERSE); SP_PARM->_slk->maxlab = ((numlab > 0) ? numlab : MAX_SKEY(SP_PARM->slk_format)); SP_PARM->_slk->maxlen = ((numlab > 0) ? LabelWidth * LabelHeight : MAX_SKEY_LEN(SP_PARM->slk_format)); SP_PARM->_slk->labcnt = ((SP_PARM->_slk->maxlab < MAX_SKEY(SP_PARM->slk_format)) ? MAX_SKEY(SP_PARM->slk_format) : SP_PARM->_slk->maxlab); if (SP_PARM->_slk->maxlen <= 0 || SP_PARM->_slk->labcnt <= 0 || (SP_PARM->_slk->ent = typeCalloc(slk_ent, (unsigned) SP_PARM->_slk->labcnt)) == NULL) returnCode(slk_failed(NCURSES_SP_ARG)); max_length = SP_PARM->_slk->maxlen; for (i = 0; i < SP_PARM->_slk->labcnt; i++) { size_t used = max_length + 1; SP_PARM->_slk->ent[i].ent_text = (char *) _nc_doalloc(0, used); if (SP_PARM->_slk->ent[i].ent_text == 0) returnCode(slk_failed(NCURSES_SP_ARG)); memset(SP_PARM->_slk->ent[i].ent_text, 0, used); SP_PARM->_slk->ent[i].form_text = (char *) _nc_doalloc(0, used); if (SP_PARM->_slk->ent[i].form_text == 0) returnCode(slk_failed(NCURSES_SP_ARG)); memset(SP_PARM->_slk->ent[i].form_text, 0, used); memset(SP_PARM->_slk->ent[i].form_text, ' ', max_length); SP_PARM->_slk->ent[i].visible = (char) (i < SP_PARM->_slk->maxlab); } res = _nc_format_slks(NCURSES_SP_ARGx cols); if ((SP_PARM->_slk->win = stwin) == NULL) { returnCode(slk_failed(NCURSES_SP_ARG)); } /* We now reset the format so that the next newterm has again * per default no SLK keys and may call slk_init again to * define a new layout. (juergen 03-Mar-1999) */ _nc_globals.slk_format = 0; returnCode(res); }
_nc_slk_initialize(WINDOW *stwin, int cols) { int i, x; int res = OK; unsigned max_length; T((T_CALLED("_nc_slk_initialize()"))); if (SP->_slk) { /* we did this already, so simply return */ returnCode(OK); } else if ((SP->_slk = typeCalloc(SLK, 1)) == 0) returnCode(ERR); SP->_slk->ent = NULL; /* * If we use colors, vidputs() will suppress video attributes that conflict * with colors. In that case, we're still guaranteed that "reverse" would * work. */ if ((no_color_video & 1) == 0) SetAttr(SP->_slk->attr, A_STANDOUT); else SetAttr(SP->_slk->attr, A_REVERSE); SP->_slk->maxlab = ((num_labels > 0) ? num_labels : MAX_SKEY(_nc_globals.slk_format)); SP->_slk->maxlen = ((num_labels > 0) ? label_width * label_height : MAX_SKEY_LEN(_nc_globals.slk_format)); SP->_slk->labcnt = ((SP->_slk->maxlab < MAX_SKEY(_nc_globals.slk_format)) ? MAX_SKEY(_nc_globals.slk_format) : SP->_slk->maxlab); if (SP->_slk->maxlen <= 0 || SP->_slk->labcnt <= 0 || (SP->_slk->ent = typeCalloc(slk_ent, (unsigned) SP->_slk->labcnt)) == NULL) returnCode(slk_failed()); max_length = SP->_slk->maxlen; for (i = 0; i < SP->_slk->labcnt; i++) { size_t used = max_length + 1; if ((SP->_slk->ent[i].ent_text = (char *) _nc_doalloc(0, used)) == 0) returnCode(slk_failed()); memset(SP->_slk->ent[i].ent_text, 0, used); if ((SP->_slk->ent[i].form_text = (char *) _nc_doalloc(0, used)) == 0) returnCode(slk_failed()); memset(SP->_slk->ent[i].form_text, 0, used); memset(SP->_slk->ent[i].form_text, ' ', max_length); SP->_slk->ent[i].visible = (char) (i < SP->_slk->maxlab); } if (_nc_globals.slk_format >= 3) { /* PC style */ int gap = (cols - 3 * (3 + 4 * max_length)) / 2; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].ent_x = x; x += max_length; x += (i == 3 || i == 7) ? gap : 1; } } else { if (_nc_globals.slk_format == 2) { /* 4-4 */ int gap = cols - (SP->_slk->maxlab * max_length) - 6; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].ent_x = x; x += max_length; x += (i == 3) ? gap : 1; } } else { if (_nc_globals.slk_format == 1) { /* 1 -> 3-2-3 */ int gap = (cols - (SP->_slk->maxlab * max_length) - 5) / 2; if (gap < 1) gap = 1; for (i = x = 0; i < SP->_slk->maxlab; i++) { SP->_slk->ent[i].ent_x = x; x += max_length; x += (i == 2 || i == 4) ? gap : 1; } } else returnCode(slk_failed()); } } SP->_slk->dirty = TRUE; if ((SP->_slk->win = stwin) == NULL) { returnCode(slk_failed()); } /* We now reset the format so that the next newterm has again * per default no SLK keys and may call slk_init again to * define a new layout. (juergen 03-Mar-1999) */ SP->slk_format = _nc_globals.slk_format; _nc_globals.slk_format = 0; returnCode(res); }
"d dump state of test arrays", "h apply hash mapper and see scroll optimization", "? this message" }; size_t n; for (n = 0; n < sizeof(table)/sizeof(table[0]); n++) fprintf(stderr, "%s\n", table[n]); } int main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED) { char line[BUFSIZ], *st; int n; SP = typeCalloc(SCREEN,1); for (n = 0; n < screen_lines; n++) { reallines[n] = n; oldnums[n] = _NEWINDEX; oldtext[n][0] = newtext[n][0] = '.'; } if (isatty(fileno(stdin))) usage(); #ifdef TRACE _nc_tracing = TRACE_MOVE; #endif for (;;) {