This patch applies to UnixFrotz232R2Std10.tar.gz as found in the IF archive and modifies the terminal I/O routines. Notable changes in functionality: * The terminal erase character, as set with stty, now functions as backspace. On many terminals this character is DEL. * Background colours should now work properly. * timeout() from curses is now used for timed input instead of a busy loop. * ^L and ^R now redraw the screen. They are not passed as input to the Z-machine. * ISO-Latin-1 characters are now valid input unless in plain ASCII mode. This makes the meta bit unusable for hotkeys. On terminals with 8-bit character sets alt usually sends ESC anyway. * History search has been added. Type the beginning of a past command and hit the up or down arrow key. In addition there are lots of cosmetic changes. I have only tested this with Ncurses -- other curses implementations might cause problems I know nothing of. But I have completed Beyond Zork and Border Zone with the patched Frotz (you need to use page up/down to scroll the upper window in Beyond Zork). Timo Korvola --- frotz-2.32/ux_init.c.orig Sat Oct 4 04:12:10 1997 +++ frotz-2.32/ux_init.c Thu Apr 22 23:02:48 1999 @@ -320,7 +320,6 @@ else h_default_background = BLUE_COLOUR; os_set_colour(h_default_foreground, h_default_background); - bkgdset(current_color); erase(); /*os_erase_area(1, 1, h_screen_rows, h_screen_cols);*/ } --- frotz-2.32/ux_input.c.orig Fri Oct 17 23:11:33 1997 +++ frotz-2.32/ux_input.c Fri Apr 30 10:56:06 1999 @@ -10,6 +10,7 @@ #include #include #include +#include #include @@ -24,10 +25,22 @@ static struct timeval global_timeout; +/* Some special characters. */ +#define CHR_CTRL_L 12 +#define CHR_CTRL_R 18 +#define CHR_DEL 127 +#define MOD_META 0x80 + +/* These are useful for circular buffers. + */ +#define RING_DEC( ptr, beg, end) (ptr > (beg) ? --ptr : (ptr = (end))) +#define RING_INC( ptr, beg, end) (ptr < (end) ? ++ptr : (ptr = (beg))) + #define MAX_HISTORY 20 static char *history_buffer[MAX_HISTORY]; -static short history_pointer = 0; /* Pointer to next available slot */ -static short history_frame = 0; /* Pointer to what the user's looking at */ +static char **history_next = history_buffer; /* Next available slot. */ +static char **history_view = history_buffer; /* What the user is looking at. */ +#define history_end (history_buffer + MAX_HISTORY - 1) extern bool is_terminator (zchar); extern void read_string (int, zchar *); @@ -56,107 +69,147 @@ } } +/* This returns the number of milliseconds until the input timeout + * elapses or zero if it has already elapsed. -1 is returned if no + * timeout is in effect, otherwise the return value is non-negative. + */ +static int timeout_to_ms() +{ + struct timeval now, diff; + + if (global_timeout.tv_sec == 0) return -1; + gettimeofday( &now, NULL); + diff.tv_usec = global_timeout.tv_usec - now.tv_usec; + if (diff.tv_usec < 0) { + /* Carry */ + now.tv_sec++; + diff.tv_usec += 1000000; + } + diff.tv_sec = global_timeout.tv_sec - now.tv_sec; + if (diff.tv_sec < 0) return 0; + if (diff.tv_sec >= INT_MAX / 1000 - 1) /* Paranoia... */ + return INT_MAX - 1000; + return diff.tv_sec * 1000 + diff.tv_usec / 1000; +} + /* * unix_read_char * - * This uses the curses getch() routine to get the next character typed, - * and returns it unless the global timeout is reached. It returns values - * which the standard considers to be legal input, and also returns editing - * and frotz hot keys. If called with a non-zero flag, it will also return - * line-editing keys like INSERT, etc, + * This uses the curses getch() routine to get the next character + * typed, and returns it. It returns values which the standard + * considers to be legal input, and also returns editing and frotz hot + * keys. If called with extkeys set it will also return line-editing + * keys like INSERT etc. * + * If unix_set_global_timeout has been used to set a global timeout + * this routine may also return ZC_TIME_OUT if input times out. */ - -static int unix_read_char(int flag) +static int unix_read_char(int extkeys) { int c; - struct timeval ctime; while(1) { - /* Timed keyboard input. Crude but functional. */ - if (global_timeout.tv_sec) { - nodelay(stdscr, TRUE); - do { - c = getch(); - if (c == ERR) { - gettimeofday(&ctime, NULL); - if ((ctime.tv_sec >= global_timeout.tv_sec) && - (ctime.tv_usec >= global_timeout.tv_usec)) { - nodelay(stdscr, FALSE); - return 0; - } - } - } while (c == ERR); - nodelay(stdscr, FALSE); - } - /* The easy way. */ - else c = getch(); - - /* Catch 98% of all input right here... */ - if ( ((c >= 32) && (c <= 126)) || (c == 13) || (c == 8)) - return c; - - /* ...and the other 2% makes up 98% of the code. :( */ - switch(c) { - /* Lucian P. Smith reports KEY_ENTER on Irix 5.3. 10 has never - been reported, but I'm leaving it in just in case. */ - case 10: case KEY_ENTER: return 13; - /* I've seen KEY_BACKSPACE returned on some terminals. */ - case KEY_BACKSPACE: return 8; - /* On seven-bit connections, "Alt-Foo" is returned as an escape - followed by the ASCII value of the letter. We have to decide - here whether to return a single escape or a frotz hot key. */ - case 27: nodelay(stdscr, TRUE); c = getch(); nodelay(stdscr, FALSE); - if (c == ERR) return 27; - switch(c) { - case 112: return ZC_HKEY_PLAYBACK; /* Alt-P */ - case 114: return ZC_HKEY_RECORD; /* Alt-R */ - case 115: return ZC_HKEY_SEED; /* Alt-S */ - case 117: return ZC_HKEY_UNDO; /* Alt-U */ - case 110: return ZC_HKEY_RESTART; /* Alt-N */ - case 120: return ZC_HKEY_QUIT; /* Alt-X */ - case 100: return ZC_HKEY_DEBUG; /* Alt-D */ - case 104: return ZC_HKEY_HELP; /* Alt-H */ - default: return 27; - } - break; + timeout( timeout_to_ms()); + c = getch(); + + /* Catch 98% of all input right here... */ + if ((c >= ZC_ASCII_MIN && c <= ZC_ASCII_MAX) + || (!unix_plain_ascii + && c >= ZC_LATIN1_MIN && c <= ZC_LATIN1_MAX)) + return c; + + /* ...and the other 2% makes up 98% of the code. :( */ + + /* On many terminals the backspace key returns DEL. */ + if (c == erasechar()) return ZC_BACKSPACE;; + switch(c) { + /* Normally ERR means timeout. I suppose we might also get + ERR if a signal hits getch. */ + case ERR: + if (timeout_to_ms() == 0) + return ZC_TIME_OUT; + else + continue; + /* Screen decluttering. */ + case CHR_CTRL_L: case CHR_CTRL_R: + clearok( curscr, 1); refresh(); clearok( curscr, 0); + continue; + /* Lucian P. Smith reports KEY_ENTER on Irix 5.3. LF has never + been reported, but I'm leaving it in just in case. */ + case '\n': case '\r': case KEY_ENTER: return ZC_RETURN; + /* I've seen KEY_BACKSPACE returned on some terminals. */ + case KEY_BACKSPACE: case '\b': return ZC_BACKSPACE; + /* On terminals with 8-bit character sets or 7-bit connections + "Alt-Foo" may be returned as an escape followed by the ASCII + value of the letter. We have to decide here whether to + return a single escape or a frotz hot key. */ + case ZC_ESCAPE: + nodelay(stdscr, TRUE); c = getch(); nodelay(stdscr, FALSE); + switch(c) { + case ERR: return ZC_ESCAPE; + case 'p': return ZC_HKEY_PLAYBACK; + case 'r': return ZC_HKEY_RECORD; + case 's': return ZC_HKEY_SEED; + case 'u': return ZC_HKEY_UNDO; + case 'n': return ZC_HKEY_RESTART; + case 'x': return ZC_HKEY_QUIT; + case 'd': return ZC_HKEY_DEBUG; + case 'h': return ZC_HKEY_HELP; + default: continue; /* Ignore unknown combinations. */ + } /* The standard function key block. */ - case KEY_UP: return 129; - case KEY_DOWN: return 130; - case KEY_LEFT: return 131; - case KEY_RIGHT: return 132; - case KEY_F(1): return 133; case KEY_F(2): return 134; - case KEY_F(3): return 135; case KEY_F(4): return 136; - case KEY_F(5): return 137; case KEY_F(6): return 138; - case KEY_F(7): return 139; case KEY_F(8): return 140; - case KEY_F(9): return 141; case KEY_F(10): return 142; - case KEY_F(11): return 143; case KEY_F(12): return 144; - /* Curses can't differentiate keypad numbers from cursor keys. Damn. */ - /* This will catch the alt-keys on 8-bit clean input streams... */ - case 240: return ZC_HKEY_PLAYBACK; /* Alt-P */ - case 242: return ZC_HKEY_RECORD; /* Alt-R */ - case 243: return ZC_HKEY_SEED; /* Alt-S */ - case 245: return ZC_HKEY_UNDO; /* Alt-U */ - case 238: return ZC_HKEY_RESTART; /* Alt-N */ - case 248: return ZC_HKEY_QUIT; /* Alt-X */ - case 228: return ZC_HKEY_DEBUG; /* Alt-D */ - case 232: return ZC_HKEY_HELP; /* Alt-H */ + case KEY_UP: return ZC_ARROW_UP; + case KEY_DOWN: return ZC_ARROW_DOWN; + case KEY_LEFT: return ZC_ARROW_LEFT; + case KEY_RIGHT: return ZC_ARROW_RIGHT; + case KEY_F(1): return ZC_FKEY_MIN; + case KEY_F(2): return ZC_FKEY_MIN + 1; + case KEY_F(3): return ZC_FKEY_MIN + 2; + case KEY_F(4): return ZC_FKEY_MIN + 3; + case KEY_F(5): return ZC_FKEY_MIN + 4; + case KEY_F(6): return ZC_FKEY_MIN + 5; + case KEY_F(7): return ZC_FKEY_MIN + 6; + case KEY_F(8): return ZC_FKEY_MIN + 7; + case KEY_F(9): return ZC_FKEY_MIN + 8; + case KEY_F(10): return ZC_FKEY_MIN + 9; + case KEY_F(11): return ZC_FKEY_MIN + 10; + case KEY_F(12): return ZC_FKEY_MIN + 11; + /* Curses can't differentiate keypad numbers from cursor keys, + which is annoying, as cursor and keypad keys have + nothing to do with each other on, say, a vt200. + So we can only read 1, 3, 5, 7 and 9 from the keypad. This + would be so silly that we choose not to provide keypad keys at all. + */ + /* Catch the meta key on those plain old ASCII terminals where + it sets the high bit. This only works in + unix_plain_ascii mode: otherwise these character codes + would have been interpreted according to ISO-Latin-1 + earlier. */ + case MOD_META | 'p': return ZC_HKEY_PLAYBACK; + case MOD_META | 'r': return ZC_HKEY_RECORD; + case MOD_META | 's': return ZC_HKEY_SEED; + case MOD_META | 'u': return ZC_HKEY_UNDO; + case MOD_META | 'n': return ZC_HKEY_RESTART; + case MOD_META | 'x': return ZC_HKEY_QUIT; + case MOD_META | 'd': return ZC_HKEY_DEBUG; + case MOD_META | 'h': return ZC_HKEY_HELP; #ifdef EMACS_EDITING - case 21: return 27; /* Ctrl-U, erase line */ - case 2: return 131; /* Ctrl-B, left arrow */ - case 6: return 132; /* Ctrl-F, right arrow */ - case 16: return 129; /* Ctrl-P, up arrow */ - case 14: return 130; /* Ctrl-N, down arrow */ - case 1: c = KEY_HOME; break; /* Ctrl-A */ - case 4: c = 127; break; /* Ctrl-D */ - case 5: c = KEY_END; break; /* Ctrl-E */ + case 21: return ZC_ESCAPE; /* Ctrl-U, erase line */ + case 2: return ZC_ARROW_LEFT; /* Ctrl-B */ + case 6: return ZC_ARROW_RIGHT; /* Ctrl-F */ + case 16: return ZC_ARROW_UP; /* Ctrl-P */ + case 14: return ZC_ARROW_DOWN; /* Ctrl-N */ + case 1: c = KEY_HOME; break; /* Ctrl-A */ + case 4: c = CHR_DEL; break; /* Ctrl-D */ + case 5: c = KEY_END; break; /* Ctrl-E */ #endif default: break; /* Who knows? */ - } + } - /* Finally, if we're in full line mode (os_read_line), we might return - codes which aren't legal Z-machine keys but are used by the editor. */ - if (flag) return c; + /* Finally, if we're in full line mode (os_read_line), we + might return codes which aren't legal Z-machine keys but + are used by the editor. */ + if (extkeys) return c; } } @@ -164,65 +217,67 @@ /* * unix_add_to_history * - * Add the given string to the next available history buffer slot. Commandeer - * that slot if necessary using realloc. + * Add the given string to the next available history buffer slot. * */ static void unix_add_to_history(zchar *str) { - if (history_buffer[history_pointer] == NULL) - history_buffer[history_pointer] = (char *) malloc(strlen(str) + 1); - else - history_buffer[history_pointer] = - (char *) realloc(history_buffer[history_pointer], strlen(str) + 1); - strcpy(history_buffer[history_pointer], str); - history_pointer = ((history_pointer + 1) % MAX_HISTORY); - history_frame = history_pointer; /* Reset user frame after each line */ + if (*history_next != NULL) + free( *history_next); + *history_next = (char *)malloc(strlen(str) + 1); + strcpy( *history_next, str); + RING_INC( history_next, history_buffer, history_end); + history_view = history_next; /* Reset user frame after each line */ } /* * unix_history_back * * Copy last available string to str, if possible. Return 1 if successful. - * + * Only lines of at most maxlen characters will be considered. In addition + * the first searchlen characters of the history entry must match those of str. */ - -static int unix_history_back(zchar *str) +static int unix_history_back(zchar *str, int searchlen, int maxlen) { + char **prev = history_view; - history_frame--; if (history_frame==-1) history_frame = (MAX_HISTORY - 1); - if ((history_frame == history_pointer) || - (history_buffer[history_frame] == NULL)) { - beep(); history_frame = (history_frame + 1) % MAX_HISTORY; - return 0; - } - strcpy(str, history_buffer[history_frame]); + do { + RING_DEC( history_view, history_buffer, history_end); + if ((history_view == history_next) + || (*history_view == NULL)) { + beep(); + history_view = prev; + return 0; + } + } while (strlen( *history_view) > maxlen + || (searchlen != 0 && strncmp( str, *history_view, searchlen))); + strcpy(str + searchlen, *history_view + searchlen); return 1; - } /* * unix_history_forward * * Opposite of unix_history_back, and works in the same way. - * */ - -static int unix_history_forward(zchar *str) +static int unix_history_forward(zchar *str, int searchlen, int maxlen) { + char **prev = history_view; - history_frame = (history_frame + 1) % MAX_HISTORY; - if ((history_frame == history_pointer) || - (history_buffer[history_frame] == NULL)) { - beep(); history_frame--; if (history_frame == -1) history_frame = - (MAX_HISTORY - 1); - return 0; - } - strcpy(str, history_buffer[history_frame]); + do { + RING_INC( history_view, history_buffer, history_end); + if ((history_view == history_next) + || (*history_view == NULL)) { + beep(); + history_view = prev; + return 0; + } + } while (strlen( *history_view) > maxlen + || (searchlen != 0 && strncmp( str, *history_view, searchlen))); + strcpy(str + searchlen, *history_view + searchlen); return 1; - } /* @@ -253,7 +308,7 @@ * ZC_HKEY_HELP (Alt-H) * * If the timeout argument is not zero, the input gets interrupted - * after timeout/10 seconds (and the return value is 0). + * after timeout/10 seconds (and the return value is ZC_TIME_OUT). * * The complete input line including the cursor must fit in "width" * screen units. @@ -273,145 +328,161 @@ zchar os_read_line (int max, zchar *buf, int timeout, int width, int continued) { - int ch, scrpos, pos, y, x; - char insert_flag = 1; /* Insert mode is now default */ - - scrpos = pos = strlen((char *) buf); - - if (!continued) - history_frame = history_pointer; /* Reset user's history view */ - - unix_set_global_timeout(timeout); + int ch, y, x, len = strlen( (char *)buf); + /* These are static to allow input continuation to work smoothly. */ + static int scrpos = 0, searchpos = -1, insert_flag = 1; getyx(stdscr, y, x); + if (width < max) max = width; + /* Better be careful here or it might segv. I wonder if we should just + ignore 'continued' and check for len > 0 instead? Might work better + with Beyond Zork. */ + if (continued && scrpos <= len && searchpos <= len) { + x += scrpos - len; + move( y, x); + } else { + scrpos = len; + history_view = history_next; /* Reset user's history view. */ + searchpos = -1; /* -1 means initialize from len. */ + insert_flag = 1; /* Insert mode is now default. */ + } - do { - refresh(); /* Shouldn't be necessary, but is, to print spaces */ - - ch = unix_read_char(1); - - /* Backspace */ - if ((ch == 8) && (scrpos)) { - mvdelch(y, --x); - pos--; scrpos--; - if (scrpos != pos) - memmove(&(buf[scrpos]), &(buf[scrpos+1]), pos-scrpos); - } - - /* Delete */ - if (((ch == 127) || (ch == KEY_DC)) && (scrpos < pos)) { - delch(); pos--; - memmove(&(buf[scrpos]), &(buf[scrpos+1]), pos-scrpos); - } - - /* Left key */ - if ((ch == 131) && (scrpos)) { - scrpos--; - move(y, --x); - } - /* Right key */ - if ((ch == 132) && (scrpos < pos)) { - scrpos++; - move(y, ++x); - } - - /* Home */ - if (ch == KEY_HOME) { - x -= scrpos; scrpos = 0; + unix_set_global_timeout(timeout); + for (;;) { + switch (ch = unix_read_char(1)) { + case ZC_BACKSPACE: + if (scrpos > 0) { + mvdelch(y, --x); + len--; scrpos--; searchpos = -1; + if (scrpos != len) + memmove(&(buf[scrpos]), &(buf[scrpos+1]), len-scrpos); + } + break; + case CHR_DEL: + case KEY_DC: /* Delete Character */ + if (scrpos < len) { + delch(); + len--; searchpos = -1; + memmove(&(buf[scrpos]), &(buf[scrpos+1]), len-scrpos); + } + continue; /* Don't feed is_terminator bad zchars. */ + case ZC_ARROW_LEFT: + if (scrpos > 0) { + scrpos--; + move(y, --x); + } + continue; + case ZC_ARROW_RIGHT: + if (scrpos < len) { + scrpos++; + move(y, ++x); + } + continue; + case KEY_HOME: + x -= scrpos; + scrpos = 0; move(y, x); - } - /* End */ - if (ch == KEY_END) { - x += (pos - scrpos); scrpos = pos; + continue; + case KEY_END: + x += (len - scrpos); scrpos = len; move(y,x); - } - - /* Insert */ - if (ch == KEY_IC) - insert_flag = (insert_flag ? 0 : 1); - - /* Up and down keys */ - if (ch == 129) { - if (unix_history_back(buf)) { - x -= scrpos; - move(y, x); - while (scrpos) {addch(' '); scrpos--;} - move(y, x); - addstr(buf); - scrpos = pos = strlen(buf); - x += scrpos; + continue; + case KEY_IC: /* Insert Character */ + insert_flag = !insert_flag; + continue; + case ZC_ARROW_UP: + if (searchpos < 0) + searchpos = len; + if (unix_history_back(buf, searchpos, max)) { + x -= scrpos; + move(y, x); + clrtoeol(); + addstr(buf); + x += scrpos = len = strlen(buf); } - } - if (ch == 130) { - if (unix_history_forward(buf)) { - x -= scrpos; - move(y, x); - while(scrpos) {addch(' '); scrpos--;} - move(y, x); - addstr(buf); - scrpos = pos = strlen(buf); - x += scrpos; + continue; + case ZC_ARROW_DOWN: + if (searchpos < 0) + searchpos = len; + if (unix_history_forward(buf, searchpos, max)) { + x -= scrpos; + move(y, x); + clrtoeol(); + addstr(buf); + x += scrpos = len = strlen(buf); } - } - - /* Page up/down (passthrough as up/down arrows for beyond zork) */ - if (ch == KEY_PPAGE) ch = 129; - if (ch == KEY_NPAGE) ch = 130; - - /* Escape */ - if (ch == 27) { - /* Move cursor to end of buffer first */ - x += (pos - scrpos); scrpos = pos; move(y,x); + continue; + /* Passthrough as up/down arrows for Beyond Zork. */ + case KEY_PPAGE: ch = ZC_ARROW_UP; break; + case KEY_NPAGE: ch = ZC_ARROW_DOWN; break; + case ZC_ESCAPE: x -= scrpos; move(y, x); - while (scrpos) {addch(' '); scrpos--;} - move(y, x); pos = 0; - } - - /* Tab */ - if ((ch == 9) && (scrpos == pos)) { - int status; - zchar extension[10]; - - status = completion(buf, extension); - if (status != 2) { - addstr(extension); - strcpy(&buf[pos], extension); - pos += strlen(extension); scrpos += strlen(extension); + clrtoeol(); + scrpos = len = 0; + searchpos = -1; + history_view = history_next; + break; + case '\t': + /* This really should be fixed to work also in the middle of a + sentence. */ + if (scrpos == len) { + int status; + zchar extension[10]; + + buf[len] = '\0'; + status = completion( buf, extension); + if (status != 2) { + strncpy( &buf[len], extension, max - len); + len += strlen( extension); + if (len > max) {len = max; status = 1;} + addnstr( extension, len - scrpos); + x += len - scrpos; + scrpos = len; + searchpos = -1; + } + if (status) beep(); + } + continue; /* TAB is invalid as an input character. */ + default: + /* ASCII or ISO-Latin-1 */ + if ((ch >= ZC_ASCII_MIN && ch <= ZC_ASCII_MAX) + || (!unix_plain_ascii + && ch >= ZC_LATIN1_MIN && ch <= ZC_LATIN1_MAX)) { + if (len == scrpos) + /* Append to end of buffer */ + if (len < max) { + buf[len++] = (char) ch; + addch(ch); + scrpos++; x++; + } else + beep(); + else + /* Insert/overwrite in middle of buffer */ + if (insert_flag) { + memmove(&buf[scrpos+1], &buf[scrpos], len-scrpos); + buf[scrpos++] = (char) ch; + insch(ch); + len++; x++; move(y, x); + } else { + buf[scrpos++] = (char) ch; + addch(ch); + x++; + } + searchpos = -1; } - if (status) beep(); - } - - /* ASCII printable */ - if ((ch >= 32) && (ch <= 126)) { - if (pos == scrpos) { - /* Append to end of buffer */ - if ((pos < max) && (pos < width)) { - buf[pos++] = (char) ch; - addch(ch); - scrpos++; x++; - } else beep(); - } - else { - /* Insert/overwrite in middle of buffer */ - if (insert_flag) { - memmove(&buf[scrpos+1], &buf[scrpos], pos-scrpos); - buf[scrpos++] = (char) ch; - insch(ch); - pos++; x++; move(y, x); - } else { - buf[scrpos++] = (char) ch; - addch(ch); - x++; - } - } } - } while (!is_terminator(ch)); - - buf[pos] = '\0'; - if (ch == 13) unix_add_to_history(buf); - return ch; - + if (is_terminator(ch)) { + buf[len] = '\0'; + if (ch == ZC_RETURN) + unix_add_to_history(buf); + /* Games don't know about line editing and might get + confused if the cursor is not at the end of the input + line. */ + move( y, x + len - scrpos); + return ch; + } + } }/* os_read_line */ /* @@ -487,3 +558,9 @@ return 1; } /* os_read_file_name */ + +/* + * Local Variables: + * c-basic-offset: 4 + * End: + */ --- frotz-2.32/ux_text.c.orig Sat Oct 4 04:12:10 1997 +++ frotz-2.32/ux_text.c Sat Apr 24 12:45:17 1999 @@ -111,26 +111,21 @@ * */ -#ifdef COLOR_SUPPORT -static int colorspace[10][10]; -static int count = 0; -#endif - void os_set_colour (int new_foreground, int new_background) { #ifdef COLOR_SUPPORT - int saved_style; + static int colorspace[10][10]; + static int n_colors = 0; - saved_style = current_text_style; if (new_foreground == 1) new_foreground = h_default_foreground; if (new_background == 1) new_background = h_default_background; if (!colorspace[new_foreground][new_background]) { - init_pair(++count, unix_convert(new_foreground), unix_convert(new_background)); - colorspace[new_foreground][new_background] = count; + init_pair(++n_colors, unix_convert(new_foreground), + unix_convert(new_background)); + colorspace[new_foreground][new_background] = n_colors; } current_color = COLOR_PAIR(colorspace[new_foreground][new_background]); - os_set_text_style(saved_style); - + bkgdset( current_color | ' '); #endif }/* os_set_colour */ @@ -154,12 +149,7 @@ if (new_style & REVERSE_STYLE) temp |= A_REVERSE; if (new_style & BOLDFACE_STYLE) temp |= A_BOLD; if (new_style & EMPHASIS_STYLE) temp |= A_UNDERLINE; -#ifdef COLOR_SUPPORT - attrset(temp | current_color); -#else attrset(temp); -#endif - }/* os_set_text_style */ /* @@ -211,7 +201,7 @@ addch(c); return; } - if (c >= 32 && c <= 126) { + if (c >= ZC_ASCII_MIN && c <= ZC_ASCII_MAX) { addch(c); return; }