X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/f278d6f8b2cf652516548664d5c0d5103683c4f6..875e0b16f64f7b97171d58fe34ebcd57314eb739:/terminal.c diff --git a/terminal.c b/terminal.c index f4122446..2a9470ba 100644 --- a/terminal.c +++ b/terminal.c @@ -60,19 +60,34 @@ const wchar_t sel_nl[] = SEL_NL; /* + * Fetch the character at a particular position in a line array, + * for purposes of `wordtype'. The reason this isn't just a simple + * array reference is that if the character we find is UCSWIDE, + * then we must look one space further to the left. + */ +#define UCSGET(a, x) \ + ( (x)>0 && ((a)[(x)] & (CHAR_MASK | CSET_MASK)) == UCSWIDE ? \ + (a)[(x)-1] : (a)[(x)] ) + +/* * Internal prototypes. */ +static unsigned long *resizeline(unsigned long *, int); +static unsigned long *lineptr(Terminal *, int, int); static void do_paint(Terminal *, Context, int); static void erase_lots(Terminal *, int, int, int); static void swap_screen(Terminal *, int, int, int); static void update_sbar(Terminal *); static void deselect(Terminal *); static void term_print_finish(Terminal *); +#ifdef OPTIMISE_SCROLL +static void scroll_display(Terminal *, int, int, int); +#endif /* OPTIMISE_SCROLL */ /* * Resize a line to make it `cols' columns wide. */ -unsigned long *resizeline(unsigned long *line, int cols) +static unsigned long *resizeline(unsigned long *line, int cols) { int i, oldlen; unsigned long lineattrs; @@ -95,11 +110,24 @@ unsigned long *resizeline(unsigned long *line, int cols) } /* + * Get the number of lines in the scrollback. + */ +static int sblines(Terminal *term) +{ + int sblines = count234(term->scrollback); + if (term->cfg.erase_to_scrollback && + term->alt_which && term->alt_screen) { + sblines += term->alt_sblines; + } + return sblines; +} + +/* * Retrieve a line of the screen or of the scrollback, according to * whether the y coordinate is non-negative or negative * (respectively). */ -unsigned long *lineptr(Terminal *term, int y, int lineno) +static unsigned long *lineptr(Terminal *term, int y, int lineno) { unsigned long *line, *newline; tree234 *whichtree; @@ -109,8 +137,19 @@ unsigned long *lineptr(Terminal *term, int y, int lineno) whichtree = term->screen; treeindex = y; } else { - whichtree = term->scrollback; - treeindex = y + count234(term->scrollback); + int altlines = 0; + if (term->cfg.erase_to_scrollback && + term->alt_which && term->alt_screen) { + altlines = term->alt_sblines; + } + if (y < -altlines) { + whichtree = term->scrollback; + treeindex = y + altlines + count234(term->scrollback); + } else { + whichtree = term->alt_screen; + treeindex = y + term->alt_sblines; + /* treeindex = y + count234(term->alt_screen); */ + } } line = index234(whichtree, treeindex); @@ -147,10 +186,10 @@ static void power_on(Terminal *term) for (i = 0; i < term->cols; i++) term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - term->alt_om = term->dec_om = cfg.dec_om; + term->alt_om = term->dec_om = term->cfg.dec_om; term->alt_ins = term->insert = FALSE; term->alt_wnext = term->wrapnext = term->save_wnext = FALSE; - term->alt_wrap = term->wrap = cfg.wrap_mode; + term->alt_wrap = term->wrap = term->cfg.wrap_mode; term->alt_cset = term->cset = term->save_cset = 0; term->alt_utf = term->utf = term->save_utf = 0; term->utf_state = 0; @@ -162,17 +201,17 @@ static void power_on(Terminal *term) term->big_cursor = 0; term->save_attr = term->curr_attr = ATTR_DEFAULT; term->term_editing = term->term_echoing = FALSE; - term->app_cursor_keys = cfg.app_cursor; - term->app_keypad_keys = cfg.app_keypad; - term->use_bce = cfg.bce; - term->blink_is_real = cfg.blinktext; + term->app_cursor_keys = term->cfg.app_cursor; + term->app_keypad_keys = term->cfg.app_keypad; + term->use_bce = term->cfg.bce; + term->blink_is_real = term->cfg.blinktext; term->erase_char = ERASE_CHAR; term->alt_which = 0; term_print_finish(term); { int i; for (i = 0; i < 256; i++) - term->wordness[i] = cfg.wordness[i]; + term->wordness[i] = term->cfg.wordness[i]; } if (term->screen) { swap_screen(term, 1, FALSE, FALSE); @@ -188,10 +227,10 @@ static void power_on(Terminal *term) void term_update(Terminal *term) { Context ctx; - ctx = get_ctx(); + ctx = get_ctx(term->frontend); if (ctx) { int need_sbar_update = term->seen_disp_event; - if (term->seen_disp_event && cfg.scroll_on_disp) { + if (term->seen_disp_event && term->cfg.scroll_on_disp) { term->disptop = 0; /* return to main screen */ term->seen_disp_event = 0; need_sbar_update = TRUE; @@ -199,7 +238,7 @@ void term_update(Terminal *term) if (need_sbar_update) update_sbar(term); do_paint(term, ctx, TRUE); - sys_cursor(term->curs.x, term->curs.y - term->disptop); + sys_cursor(term->frontend, term->curs.x, term->curs.y - term->disptop); free_ctx(ctx); } } @@ -229,7 +268,7 @@ void term_seen_key_event(Terminal *term) /* * Reset the scrollback on keypress, if we're doing that. */ - if (cfg.scroll_on_key) { + if (term->cfg.scroll_on_key) { term->disptop = 0; /* return to main screen */ term->seen_disp_event = 1; } @@ -241,7 +280,8 @@ void term_seen_key_event(Terminal *term) void term_pwron(Terminal *term) { power_on(term); - ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */ + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); fix_cpos; term->disptop = 0; deselect(term); @@ -254,20 +294,53 @@ void term_pwron(Terminal *term) * user has disabled mouse reporting, and abandon a print job if * the user has disabled printing. */ -void term_reconfig(Terminal *term) +void term_reconfig(Terminal *term, Config *cfg) { - if (cfg.no_alt_screen) + /* + * Before adopting the new config, check all those terminal + * settings which control power-on defaults; and if they've + * changed, we will modify the current state as well as the + * default one. The full list is: Auto wrap mode, DEC Origin + * Mode, BCE, blinking text, character classes. + */ + int reset_wrap, reset_decom, reset_bce, reset_blink, reset_charclass; + int i; + + reset_wrap = (term->cfg.wrap_mode != cfg->wrap_mode); + reset_decom = (term->cfg.dec_om != cfg->dec_om); + reset_bce = (term->cfg.bce != cfg->bce); + reset_blink = (term->cfg.blinktext != cfg->blinktext); + reset_charclass = 0; + for (i = 0; i < lenof(term->cfg.wordness); i++) + if (term->cfg.wordness[i] != cfg->wordness[i]) + reset_charclass = 1; + + term->cfg = *cfg; /* STRUCTURE COPY */ + + if (reset_wrap) + term->alt_wrap = term->wrap = term->cfg.wrap_mode; + if (reset_decom) + term->alt_om = term->dec_om = term->cfg.dec_om; + if (reset_bce) + term->use_bce = term->cfg.bce; + if (reset_blink) + term->blink_is_real = term->cfg.blinktext; + if (reset_charclass) + for (i = 0; i < 256; i++) + term->wordness[i] = term->cfg.wordness[i]; + + if (term->cfg.no_alt_screen) swap_screen(term, 0, FALSE, FALSE); - if (cfg.no_mouse_rep) { + if (term->cfg.no_mouse_rep) { term->xterm_mouse = 0; - set_raw_mouse_mode(0); + set_raw_mouse_mode(term->frontend, 0); } - if (cfg.no_remote_charset) { + if (term->cfg.no_remote_charset) { term->cset_attr[0] = term->cset_attr[1] = ATTR_ASCII; term->sco_acs = term->alt_sco_acs = 0; term->utf = 0; } - if (!*cfg.printer) { + if (!*term->cfg.printer) { term_print_finish(term); } } @@ -282,13 +355,16 @@ void term_clrsb(Terminal *term) while ((line = delpos234(term->scrollback, 0)) != NULL) { sfree(line); } + term->tempsblines = 0; + term->alt_sblines = 0; update_sbar(term); } /* * Initialise the terminal. */ -Terminal *term_init(void) +Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata, + void *frontend) { Terminal *term; @@ -297,10 +373,15 @@ Terminal *term_init(void) * that need it. */ term = smalloc(sizeof(Terminal)); + term->frontend = frontend; + term->ucsdata = ucsdata; + term->cfg = *mycfg; /* STRUCTURE COPY */ + term->logctx = NULL; term->compatibility_level = TM_PUTTY; strcpy(term->id_string, "\033[?6c"); term->last_blink = term->last_tblink = 0; term->paste_buffer = NULL; + term->paste_len = 0; term->last_paste = 0; bufchain_init(&term->inbuf); bufchain_init(&term->printer_buf); @@ -309,15 +390,18 @@ Terminal *term_init(void) term->vt52_mode = FALSE; term->cr_lf_return = FALSE; term->seen_disp_event = FALSE; - term->xterm_mouse = FALSE; + term->xterm_mouse = term->mouse_is_down = FALSE; term->reset_132 = FALSE; term->blinker = term->tblinker = 0; term->has_focus = 1; term->repeat_off = FALSE; term->termstate = TOPLEVEL; term->selstate = NO_SELECTION; + term->curstype = 0; term->screen = term->alt_screen = term->scrollback = NULL; + term->tempsblines = 0; + term->alt_sblines = 0; term->disptop = 0; term->disptext = term->dispcurs = NULL; term->tabs = NULL; @@ -325,13 +409,47 @@ Terminal *term_init(void) term->rows = term->cols = -1; power_on(term); term->beephead = term->beeptail = NULL; +#ifdef OPTIMISE_SCROLL + term->scrollhead = term->scrolltail = NULL; +#endif /* OPTIMISE_SCROLL */ term->nbeeps = 0; term->lastbeep = FALSE; term->beep_overloaded = FALSE; + term->attr_mask = 0xffffffff; + term->resize_fn = NULL; + term->resize_ctx = NULL; return term; } +void term_free(Terminal *term) +{ + unsigned long *line; + struct beeptime *beep; + + while ((line = delpos234(term->scrollback, 0)) != NULL) + sfree(line); + freetree234(term->scrollback); + while ((line = delpos234(term->screen, 0)) != NULL) + sfree(line); + freetree234(term->screen); + while ((line = delpos234(term->alt_screen, 0)) != NULL) + sfree(line); + freetree234(term->alt_screen); + sfree(term->disptext); + while (term->beephead) { + beep = term->beephead; + term->beephead = beep->next; + sfree(beep); + } + bufchain_clear(&term->inbuf); + if(term->print_job) + printer_finish_job(term->print_job); + bufchain_clear(&term->printer_buf); + sfree(term->paste_buffer); + sfree(term); +} + /* * Set up the terminal for a given size. */ @@ -356,6 +474,7 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) if (term->rows == -1) { term->scrollback = newtree234(NULL); term->screen = newtree234(NULL); + term->tempsblines = 0; term->rows = 0; } @@ -365,15 +484,14 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) * will take care of resizing each individual line if * necessary. So: * - * - If the new screen and the old screen differ in length, we - * must shunt some lines in from the scrollback or out to - * the scrollback. - * - * - If doing that fails to provide us with enough material to - * fill the new screen (i.e. the number of rows needed in - * the new screen exceeds the total number in the previous - * screen+scrollback), we must invent some blank lines to - * cover the gap. + * - If the new screen is longer, we shunt lines in from temporary + * scrollback if possible, otherwise we add new blank lines at + * the bottom. + * + * - If the new screen is shorter, we remove any blank lines at + * the bottom if possible, otherwise shunt lines above the cursor + * to scrollback if possible, otherwise delete lines below the + * cursor. * * - Then, if the new scrollback length is less than the * amount of scrollback we actually have, we must throw some @@ -381,31 +499,58 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) */ sblen = count234(term->scrollback); /* Do this loop to expand the screen if newrows > rows */ - for (i = term->rows; i < newrows; i++) { - if (sblen > 0) { + assert(term->rows == count234(term->screen)); + while (term->rows < newrows) { + if (term->tempsblines > 0) { + /* Insert a line from the scrollback at the top of the screen. */ + assert(sblen >= term->tempsblines); line = delpos234(term->scrollback, --sblen); + term->tempsblines -= 1; + addpos234(term->screen, line, 0); + term->curs.y += 1; + term->savecurs.y += 1; } else { + /* Add a new blank line at the bottom of the screen. */ line = smalloc(TSIZE * (newcols + 2)); line[0] = newcols; - for (j = 0; j <= newcols; j++) + for (j = 0; j < newcols; j++) line[j + 1] = ERASE_CHAR; + line[newcols + 1] = LATTR_NORM; + addpos234(term->screen, line, count234(term->screen)); } - addpos234(term->screen, line, 0); + term->rows += 1; } /* Do this loop to shrink the screen if newrows < rows */ - for (i = newrows; i < term->rows; i++) { - line = delpos234(term->screen, 0); - addpos234(term->scrollback, line, sblen++); + while (term->rows > newrows) { + if (term->curs.y < term->rows - 1) { + /* delete bottom row, unless it contains the cursor */ + sfree(delpos234(term->screen, term->rows - 1)); + } else { + /* push top row to scrollback */ + line = delpos234(term->screen, 0); + addpos234(term->scrollback, line, sblen++); + term->tempsblines += 1; + term->curs.y -= 1; + term->savecurs.y -= 1; + } + term->rows -= 1; } + assert(term->rows == newrows); assert(count234(term->screen) == newrows); + + /* Delete any excess lines from the scrollback. */ while (sblen > newsavelines) { line = delpos234(term->scrollback, 0); sfree(line); sblen--; } + if (sblen < term->tempsblines) + term->tempsblines = sblen; assert(count234(term->scrollback) <= newsavelines); + assert(count234(term->scrollback) >= term->tempsblines); term->disptop = 0; + /* Make a new displayed text buffer. */ newdisp = smalloc(newrows * (newcols + 1) * TSIZE); for (i = 0; i < newrows * (newcols + 1); i++) newdisp[i] = ATTR_INVALID; @@ -413,12 +558,14 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) term->disptext = newdisp; term->dispcurs = NULL; + /* Make a new alternate screen. */ newalt = newtree234(NULL); for (i = 0; i < newrows; i++) { line = smalloc(TSIZE * (newcols + 2)); line[0] = newcols; - for (j = 0; j <= newcols; j++) + for (j = 0; j < newcols; j++) line[j + 1] = term->erase_char; + line[newcols + 1] = LATTR_NORM; addpos234(newalt, line, i); } if (term->alt_screen) { @@ -427,6 +574,7 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) freetree234(term->alt_screen); } term->alt_screen = newalt; + term->alt_sblines = 0; term->tabs = srealloc(term->tabs, newcols * sizeof(*term->tabs)); { @@ -435,8 +583,11 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - if (term->rows > 0) - term->curs.y += newrows - term->rows; + /* Check that the cursor positions are still valid. */ + if (term->savecurs.y < 0) + term->savecurs.y = 0; + if (term->savecurs.y >= newrows) + term->savecurs.y = newrows - 1; if (term->curs.y < 0) term->curs.y = 0; if (term->curs.y >= newrows) @@ -455,7 +606,41 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) update_sbar(term); term_update(term); - back->size(term->cols, term->rows); + if (term->resize_fn) + term->resize_fn(term->resize_ctx, term->cols, term->rows); +} + +/* + * Hand a function and context pointer to the terminal which it can + * use to notify a back end of resizes. + */ +void term_provide_resize_fn(Terminal *term, + void (*resize_fn)(void *, int, int), + void *resize_ctx) +{ + term->resize_fn = resize_fn; + term->resize_ctx = resize_ctx; + if (term->cols > 0 && term->rows > 0) + resize_fn(resize_ctx, term->cols, term->rows); +} + +/* Find the bottom line on the screen that has any content. + * If only the top line has content, returns 0. + * If no lines have content, return -1. + */ +static int find_last_nonempty_line(Terminal * term, tree234 * screen) +{ + int i; + for (i = count234(screen) - 1; i >= 0; i--) { + unsigned long *line = index234(screen, i); + int j; + int cols = line[0]; + for (j = 0; j < cols; j++) { + if (line[j + 1] != term->erase_char) break; + } + if (j != cols) break; + } + return i; } /* @@ -479,6 +664,7 @@ static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos) ttr = term->alt_screen; term->alt_screen = term->screen; term->screen = ttr; + term->alt_sblines = find_last_nonempty_line(term, term->alt_screen) + 1; t = term->curs.x; if (!reset && !keep_cur_pos) term->curs.x = term->alt_x; @@ -536,11 +722,9 @@ static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos) */ static void update_sbar(Terminal *term) { - int nscroll; - - nscroll = count234(term->scrollback); - - set_sbar(nscroll + term->rows, nscroll + term->disptop, term->rows); + int nscroll = sblines(term); + set_sbar(term->frontend, nscroll + term->rows, + nscroll + term->disptop, term->rows); } /* @@ -566,11 +750,13 @@ static void check_selection(Terminal *term, pos from, pos to) static void scroll(Terminal *term, int topline, int botline, int lines, int sb) { unsigned long *line, *line2; - int i, seltop; + int i, seltop, olddisptop, shift; if (topline != 0 || term->alt_which != 0) sb = FALSE; + olddisptop = term->disptop; + shift = lines; if (lines < 0) { while (lines < 0) { line = delpos234(term->screen, botline); @@ -613,6 +799,7 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) } else { line2 = smalloc(TSIZE * (term->cols + 2)); line2[0] = term->cols; + term->tempsblines += 1; } addpos234(term->scrollback, line, sblen); line = line2; @@ -637,7 +824,7 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) line = resizeline(line, term->cols); for (i = 0; i < term->cols; i++) line[i + 1] = term->erase_char; - line[term->cols + 1] = 0; + line[term->cols + 1] = LATTR_NORM; addpos234(term->screen, line, botline); /* @@ -679,7 +866,72 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) lines--; } } +#ifdef OPTIMISE_SCROLL + shift += term->disptop - olddisptop; + if (shift < term->rows && shift > -term->rows && shift != 0) + scroll_display(term, topline, botline, shift); +#endif /* OPTIMISE_SCROLL */ +} + +#ifdef OPTIMISE_SCROLL +/* + * Add a scroll of a region on the screen into the pending scroll list. + * `lines' is +ve for scrolling forward, -ve for backward. + * + * If the scroll is on the same area as the last scroll in the list, + * merge them. + */ +static void save_scroll(Terminal *term, int topline, int botline, int lines) +{ + struct scrollregion *newscroll; + if (term->scrolltail && + term->scrolltail->topline == topline && + term->scrolltail->botline == botline) { + term->scrolltail->lines += lines; + } else { + newscroll = smalloc(sizeof(struct scrollregion)); + newscroll->topline = topline; + newscroll->botline = botline; + newscroll->lines = lines; + newscroll->next = NULL; + + if (!term->scrollhead) + term->scrollhead = newscroll; + else + term->scrolltail->next = newscroll; + term->scrolltail = newscroll; + } +} + +/* + * Scroll the physical display, and our conception of it in disptext. + */ +static void scroll_display(Terminal *term, int topline, int botline, int lines) +{ + unsigned long *start, *end; + int distance, size, i; + + start = term->disptext + topline * (term->cols + 1); + end = term->disptext + (botline + 1) * (term->cols + 1); + distance = (lines > 0 ? lines : -lines) * (term->cols + 1); + size = end - start - distance; + if (lines > 0) { + memmove(start, start + distance, size * TSIZE); + if (term->dispcurs >= start + distance && + term->dispcurs <= start + distance + size) + term->dispcurs -= distance; + for (i = 0; i < distance; i++) + (start + size)[i] |= ATTR_INVALID; + } else { + memmove(start + distance, start, size * TSIZE); + if (term->dispcurs >= start && term->dispcurs <= start + size) + term->dispcurs += distance; + for (i = 0; i < distance; i++) + start[i] |= ATTR_INVALID; + } + save_scroll(term, topline, botline, lines); } +#endif /* OPTIMISE_SCROLL */ /* * Move the cursor to a given position, clipping at boundaries. We @@ -753,6 +1005,44 @@ static void save_cursor(Terminal *term, int save) } /* + * This function is called before doing _anything_ which affects + * only part of a line of text. It is used to mark the boundary + * between two character positions, and it indicates that some sort + * of effect is going to happen on only one side of that boundary. + * + * The effect of this function is to check whether a CJK + * double-width character is straddling the boundary, and to remove + * it and replace it with two spaces if so. (Of course, one or + * other of those spaces is then likely to be replaced with + * something else again, as a result of whatever happens next.) + * + * Also, if the boundary is at the right-hand _edge_ of the screen, + * it implies something deliberate is being done to the rightmost + * column position; hence we must clear LATTR_WRAPPED2. + * + * The input to the function is the coordinates of the _second_ + * character of the pair. + */ +static void check_boundary(Terminal *term, int x, int y) +{ + unsigned long *ldata; + + /* Validate input coordinates, just in case. */ + if (x == 0 || x > term->cols) + return; + + ldata = lineptr(y); + if (x == term->cols) { + ldata[x] &= ~LATTR_WRAPPED2; + } else { + if ((ldata[x] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) { + ldata[x-1] = ldata[x] = + (ldata[x-1] &~ (CHAR_MASK | CSET_MASK)) | ATTR_ASCII | ' '; + } + } +} + +/* * Erase a large portion of the screen: the whole screen, or the * whole line, or parts thereof. */ @@ -761,7 +1051,7 @@ static void erase_lots(Terminal *term, { pos start, end; int erase_lattr; - unsigned long *ldata; + int erasing_lines_from_top = 0; if (line_only) { start.y = term->curs.y; @@ -783,21 +1073,52 @@ static void erase_lots(Terminal *term, end = term->curs; incpos(end); } + if (!from_begin || !to_end) + check_boundary(term, term->curs.x, term->curs.y); check_selection(term, start, end); /* Clear screen also forces a full window redraw, just in case. */ if (start.y == 0 && start.x == 0 && end.y == term->rows) term_invalidate(term); - ldata = lineptr(start.y); - while (poslt(start, end)) { - if (start.x == term->cols && !erase_lattr) - ldata[start.x] &= ~LATTR_WRAPPED; - else - ldata[start.x] = term->erase_char; - if (incpos(start) && start.y < term->rows) - ldata = lineptr(start.y); + /* Lines scrolled away shouldn't be brought back on if the terminal + * resizes. */ + if (start.y == 0 && start.x == 0 && end.x == 0 && erase_lattr) + erasing_lines_from_top = 1; + + if (term->cfg.erase_to_scrollback && erasing_lines_from_top) { + /* If it's a whole number of lines, starting at the top, and + * we're fully erasing them, erase by scrolling and keep the + * lines in the scrollback. */ + int scrolllines = end.y; + if (end.y == term->rows) { + /* Shrink until we find a non-empty row.*/ + scrolllines = find_last_nonempty_line(term, term->screen) + 1; + } + if (scrolllines > 0) + scroll(term, 0, scrolllines - 1, scrolllines, TRUE); + fix_cpos; + } else { + unsigned long *ldata = lineptr(start.y); + while (poslt(start, end)) { + if (start.x == term->cols) { + if (!erase_lattr) + ldata[start.x] &= ~(LATTR_WRAPPED | LATTR_WRAPPED2); + else + ldata[start.x] = LATTR_NORM; + } else { + ldata[start.x] = term->erase_char; + } + if (incpos(start) && start.y < term->rows) + ldata = lineptr(start.y); + } } + + /* After an erase of lines from the top of the screen, we shouldn't + * bring the lines back again if the terminal enlarges (since the user or + * application has explictly thrown them away). */ + if (erasing_lines_from_top && !(term->alt_which)) + term->tempsblines = 0; } /* @@ -818,6 +1139,9 @@ static void insch(Terminal *term, int n) cursplus.y = term->curs.y; cursplus.x = term->curs.x + n; check_selection(term, term->curs, cursplus); + check_boundary(term, term->curs.x, term->curs.y); + if (dir < 0) + check_boundary(term, term->curs.x + n, term->curs.y); ldata = lineptr(term->curs.y); if (dir < 0) { memmove(ldata + term->curs.x, ldata + term->curs.x + n, m * TSIZE); @@ -849,13 +1173,13 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) term->blink_is_real = FALSE; term->vt52_bold = FALSE; } else { - term->blink_is_real = cfg.blinktext; + term->blink_is_real = term->cfg.blinktext; } break; case 3: /* 80/132 columns */ deselect(term); - if (!cfg.no_remote_resize) - request_resize(state ? 132 : 80, term->rows); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, state ? 132 : 80, term->rows); term->reset_132 = state; break; case 5: /* reverse video */ @@ -898,7 +1222,8 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) break; case 10: /* set local edit mode */ term->term_editing = state; - ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */ + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); break; case 25: /* enable/disable cursor */ compatibility2(OTHER, VT220); @@ -908,21 +1233,21 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) case 47: /* alternate screen */ compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, FALSE, FALSE); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, FALSE, FALSE); term->disptop = 0; break; case 1000: /* xterm mouse 1 */ term->xterm_mouse = state ? 1 : 0; - set_raw_mouse_mode(state); + set_raw_mouse_mode(term->frontend, state); break; case 1002: /* xterm mouse 2 */ term->xterm_mouse = state ? 2 : 0; - set_raw_mouse_mode(state); + set_raw_mouse_mode(term->frontend, state); break; case 1047: /* alternate screen */ compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, TRUE, TRUE); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, TRUE); term->disptop = 0; break; case 1048: /* save/restore cursor */ @@ -935,7 +1260,7 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) if (!state) term->seen_disp_event = TRUE; compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, TRUE, FALSE); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, FALSE); if (!state) save_cursor(term, state); term->disptop = 0; @@ -948,7 +1273,8 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) break; case 12: /* set echo mode */ term->term_echoing = !state; - ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */ + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); break; case 20: /* Return sends ... */ term->cr_lf_return = state; @@ -973,15 +1299,15 @@ static void do_osc(Terminal *term) switch (term->esc_args[0]) { case 0: case 1: - if (!cfg.no_remote_wintitle) - set_icon(term->osc_string); + if (!term->cfg.no_remote_wintitle) + set_icon(term->frontend, term->osc_string); if (term->esc_args[0] == 1) break; /* fall through: parameter 0 means set both */ case 2: case 21: - if (!cfg.no_remote_wintitle) - set_title(term->osc_string); + if (!term->cfg.no_remote_wintitle) + set_title(term->frontend, term->osc_string); break; } } @@ -993,7 +1319,7 @@ static void do_osc(Terminal *term) static void term_print_setup(Terminal *term) { bufchain_clear(&term->printer_buf); - term->print_job = printer_start_job(cfg.printer); + term->print_job = printer_start_job(term->cfg.printer); } static void term_print_flush(Terminal *term) { @@ -1067,8 +1393,8 @@ void term_out(Terminal *term) * Optionally log the session traffic to a file. Useful for * debugging and possibly also useful for actual logging. */ - if (cfg.logtype == LGTYP_DEBUG) - logtraffic((unsigned char) c, LGTYP_DEBUG); + if (term->cfg.logtype == LGTYP_DEBUG && term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG); } else { c = unget; unget = -1; @@ -1118,8 +1444,8 @@ void term_out(Terminal *term) case 0: if (c < 0x80) { /* UTF-8 must be stateless so we ignore iso2022. */ - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; else c = ((unsigned char)c) | ATTR_ASCII; break; } else if ((c & 0xe0) == 0xc0) { @@ -1203,9 +1529,9 @@ void term_out(Terminal *term) } /* Are we in the nasty ACS mode? Note: no sco in utf mode. */ else if(term->sco_acs && - (c!='\033' && c!='\n' && c!='\r' && c!='\b')) + (c!='\033' && c!='\012' && c!='\015' && c!='\b')) { - if (term->sco_acs == 2) c ^= 0x80; + if (term->sco_acs == 2) c |= 0x80; c |= ATTR_SCOACS; } else { switch (term->cset_attr[term->cset]) { @@ -1216,8 +1542,8 @@ void term_out(Terminal *term) * the same encoding. */ case ATTR_LINEDRW: - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; else c = ((unsigned char) c) | ATTR_LINEDRW; break; @@ -1229,8 +1555,8 @@ void term_out(Terminal *term) break; } /*FALLTHROUGH*/ case ATTR_ASCII: - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; else c = ((unsigned char) c) | ATTR_ASCII; break; @@ -1255,7 +1581,7 @@ void term_out(Terminal *term) term->curs.x--; term->wrapnext = FALSE; fix_cpos; - if (!cfg.no_dbackspace) /* destructive bksp might be disabled */ + if (!term->cfg.no_dbackspace) /* destructive bksp might be disabled */ *term->cpos = (' ' | term->curr_attr | ATTR_ASCII); } else /* Or normal C0 controls. */ @@ -1271,10 +1597,10 @@ void term_out(Terminal *term) * An xterm returns "xterm" (5 characters) */ compatibility(ANSIMIN); - { + if (term->ldisc) { char abuf[256], *s, *d; int state = 0; - for (s = cfg.answerback, d = abuf; *s; s++) { + for (s = term->cfg.answerback, d = abuf; *s; s++) { if (state) { if (*s >= 'a' && *s <= 'z') *d++ = (*s - ('a' - 1)); @@ -1289,7 +1615,8 @@ void term_out(Terminal *term) } else *d++ = *s; } - lpage_send(DEFAULT_CODEPAGE, abuf, d - abuf, 0); + lpage_send(term->ldisc, DEFAULT_CODEPAGE, + abuf, d - abuf, 0); } break; case '\007': @@ -1316,7 +1643,7 @@ void term_out(Terminal *term) * t seconds ago. */ while (term->beephead && - term->beephead->ticks < ticks - cfg.bellovl_t) { + term->beephead->ticks < ticks - term->cfg.bellovl_t) { struct beeptime *tmp = term->beephead; term->beephead = tmp->next; sfree(tmp); @@ -1325,16 +1652,16 @@ void term_out(Terminal *term) term->nbeeps--; } - if (cfg.bellovl && term->beep_overloaded && - ticks - term->lastbeep >= (unsigned)cfg.bellovl_s) { + if (term->cfg.bellovl && term->beep_overloaded && + ticks - term->lastbeep >= (unsigned)term->cfg.bellovl_s) { /* * If we're currently overloaded and the * last beep was more than s seconds ago, * leave overload mode. */ term->beep_overloaded = FALSE; - } else if (cfg.bellovl && !term->beep_overloaded && - term->nbeeps >= cfg.bellovl_n) { + } else if (term->cfg.bellovl && !term->beep_overloaded && + term->nbeeps >= term->cfg.bellovl_n) { /* * Now, if we have n or more beeps * remaining in the queue, go into overload @@ -1347,13 +1674,13 @@ void term_out(Terminal *term) /* * Perform an actual beep if we're not overloaded. */ - if (!cfg.bellovl || !term->beep_overloaded) { - if (cfg.beep == BELL_VISUAL) { + if (!term->cfg.bellovl || !term->beep_overloaded) { + beep(term->frontend, term->cfg.beep); + if (term->cfg.beep == BELL_VISUAL) { term->in_vbell = TRUE; term->vbell_startpoint = ticks; term_update(term); - } else - beep(cfg.beep); + } } term->disptop = 0; } @@ -1388,13 +1715,14 @@ void term_out(Terminal *term) term->esc_query = FALSE; } break; - case '\r': + case '\015': term->curs.x = 0; term->wrapnext = FALSE; fix_cpos; term->seen_disp_event = TRUE; term->paste_hold = 0; - logtraffic((unsigned char) c, LGTYP_ASCII); + if (term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; case '\014': if (has_compat(SCOANSI)) { @@ -1407,18 +1735,19 @@ void term_out(Terminal *term) } case '\013': compatibility(VT100); - case '\n': + case '\012': if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); else if (term->curs.y < term->rows - 1) term->curs.y++; - if (cfg.lfhascr) + if (term->cfg.lfhascr) term->curs.x = 0; fix_cpos; term->wrapnext = FALSE; term->seen_disp_event = 1; term->paste_hold = 0; - logtraffic((unsigned char) c, LGTYP_ASCII); + if (term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; case '\t': { @@ -1466,10 +1795,10 @@ void term_out(Terminal *term) incpos(cursplus); check_selection(term, term->curs, cursplus); } - if ((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0) - logtraffic((unsigned char) c, LGTYP_ASCII); + if (((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0) && + term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); { - extern int wcwidth(wchar_t ucs); int width = 0; if (DIRECT_CHAR(c)) width = 1; @@ -1477,9 +1806,30 @@ void term_out(Terminal *term) width = wcwidth((wchar_t) c); switch (width) { case 2: - *term->cpos++ = c | term->curr_attr; - if (++term->curs.x == term->cols) { - *term->cpos |= LATTR_WRAPPED; + /* + * If we're about to display a double-width + * character starting in the rightmost + * column, then we do something special + * instead. We must print a space in the + * last column of the screen, then wrap; + * and we also set LATTR_WRAPPED2 which + * instructs subsequent cut-and-pasting not + * only to splice this line to the one + * after it, but to ignore the space in the + * last character position as well. + * (Because what was actually output to the + * terminal was presumably just a sequence + * of CJK characters, and we don't want a + * space to be pasted in the middle of + * those just because they had the + * misfortune to start in the wrong parity + * column. xterm concurs.) + */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); + if (term->curs.x == term->cols-1) { + *term->cpos++ = ATTR_ASCII | ' ' | term->curr_attr; + *term->cpos |= LATTR_WRAPPED | LATTR_WRAPPED2; if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); @@ -1487,10 +1837,17 @@ void term_out(Terminal *term) term->curs.y++; term->curs.x = 0; fix_cpos; + /* Now we must check_boundary again, of course. */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); } + *term->cpos++ = c | term->curr_attr; *term->cpos++ = UCSWIDE | term->curr_attr; + term->curs.x++; break; case 1: + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+1, term->curs.y); *term->cpos++ = c | term->curr_attr; break; default: @@ -1600,15 +1957,18 @@ void term_out(Terminal *term) break; case 'Z': /* terminal type query */ compatibility(VT100); - ldisc_send(term->id_string, strlen(term->id_string), 0); + if (term->ldisc) + ldisc_send(term->ldisc, term->id_string, + strlen(term->id_string), 0); break; case 'c': /* restore power-on settings */ compatibility(VT100); power_on(term); - ldisc_send(NULL, 0, 0);/* cause ldisc to notice changes */ + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); if (term->reset_132) { - if (!cfg.no_remote_resize) - request_resize(80, term->rows); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, 80, term->rows); term->reset_132 = 0; } fix_cpos; @@ -1672,55 +2032,55 @@ void term_out(Terminal *term) case ANSI('A', '('): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[0] = ATTR_GBCHR; break; case ANSI('B', '('): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[0] = ATTR_ASCII; break; case ANSI('0', '('): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[0] = ATTR_LINEDRW; break; case ANSI('U', '('): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[0] = ATTR_SCOACS; break; case ANSI('A', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[1] = ATTR_GBCHR; break; case ANSI('B', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[1] = ATTR_ASCII; break; case ANSI('0', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[1] = ATTR_LINEDRW; break; case ANSI('U', ')'): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->cset_attr[1] = ATTR_SCOACS; break; case ANSI('8', '%'): /* Old Linux code */ case ANSI('G', '%'): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->utf = 1; break; case ANSI('@', '%'): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->utf = 0; break; } @@ -1766,7 +2126,8 @@ void term_out(Terminal *term) compatibility(OTHER); /* this reports xterm version 136 so that VIM can use the drag messages from the mouse reporting */ - ldisc_send("\033[>0;136;0c", 11, 0); + if (term->ldisc) + ldisc_send(term->ldisc, "\033[>0;136;0c", 11, 0); break; case 'a': /* move right N cols */ compatibility(ANSI); @@ -1868,17 +2229,20 @@ void term_out(Terminal *term) case 'c': /* terminal type query */ compatibility(VT100); /* This is the response for a VT102 */ - ldisc_send(term->id_string, - strlen(term->id_string), 0); + if (term->ldisc) + ldisc_send(term->ldisc, term->id_string, + strlen(term->id_string), 0); break; case 'n': /* cursor position query */ - if (term->esc_args[0] == 6) { - char buf[32]; - sprintf(buf, "\033[%d;%dR", term->curs.y + 1, - term->curs.x + 1); - ldisc_send(buf, strlen(buf), 0); - } else if (term->esc_args[0] == 5) { - ldisc_send("\033[0n", 4, 0); + if (term->ldisc) { + if (term->esc_args[0] == 6) { + char buf[32]; + sprintf(buf, "\033[%d;%dR", term->curs.y + 1, + term->curs.x + 1); + ldisc_send(term->ldisc, buf, strlen(buf), 0); + } else if (term->esc_args[0] == 5) { + ldisc_send(term->ldisc, "\033[0n", 4, 0); + } } break; case 'h': /* toggle modes to high */ @@ -1896,7 +2260,7 @@ void term_out(Terminal *term) compatibility(VT100); { if (term->esc_nargs != 1) break; - if (term->esc_args[0] == 5 && *cfg.printer) { + if (term->esc_args[0] == 5 && *term->cfg.printer) { term->printing = TRUE; term->only_printing = !term->esc_query; term->print_state = 0; @@ -2018,15 +2382,15 @@ void term_out(Terminal *term) break; case 10: /* SCO acs off */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 0; break; case 11: /* SCO acs on */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 1; break; - case 12: /* SCO acs on flipped */ + case 12: /* SCO acs on, |0x80 */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 2; break; case 22: /* disable bold */ compatibility2(OTHER, VT220); @@ -2057,6 +2421,20 @@ void term_out(Terminal *term) term->curr_attr |= (term->esc_args[i] - 30)<curr_attr &= ~ATTR_FGMASK; + term->curr_attr |= + ((term->esc_args[i] - 90 + 16) + << ATTR_FGSHIFT); + break; case 39: /* default-foreground */ term->curr_attr &= ~ATTR_FGMASK; term->curr_attr |= ATTR_DEFFG; @@ -2074,6 +2452,20 @@ void term_out(Terminal *term) term->curr_attr |= (term->esc_args[i] - 40)<curr_attr &= ~ATTR_BGMASK; + term->curr_attr |= + ((term->esc_args[i] - 100 + 16) + << ATTR_BGSHIFT); + break; case 49: /* default-background */ term->curr_attr &= ~ATTR_BGMASK; term->curr_attr |= ATTR_DEFBG; @@ -2105,8 +2497,8 @@ void term_out(Terminal *term) && (term->esc_args[0] < 1 || term->esc_args[0] >= 24)) { compatibility(VT340TEXT); - if (!cfg.no_remote_resize) - request_resize(term->cols, + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, term->cols, def(term->esc_args[0], 24)); deselect(term); } else if (term->esc_nargs >= 1 && @@ -2118,15 +2510,16 @@ void term_out(Terminal *term) int x, y, len; char buf[80], *p; case 1: - set_iconic(FALSE); + set_iconic(term->frontend, FALSE); break; case 2: - set_iconic(TRUE); + set_iconic(term->frontend, TRUE); break; case 3: if (term->esc_nargs >= 3) { - if (!cfg.no_remote_resize) - move_window(def(term->esc_args[1], 0), + if (!term->cfg.no_remote_resize) + move_window(term->frontend, + def(term->esc_args[1], 0), def(term->esc_args[2], 0)); } break; @@ -2137,44 +2530,56 @@ void term_out(Terminal *term) * manage it. */ break; case 5: - set_zorder(TRUE); /* move to top */ + /* move to top */ + set_zorder(term->frontend, TRUE); break; case 6: - set_zorder(FALSE); /* move to bottom */ + /* move to bottom */ + set_zorder(term->frontend, FALSE); break; case 7: - refresh_window(); + refresh_window(term->frontend); break; case 8: if (term->esc_nargs >= 3) { - if (!cfg.no_remote_resize) - request_resize(def(term->esc_args[2], cfg.width), - def(term->esc_args[1], cfg.height)); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, + def(term->esc_args[2], term->cfg.width), + def(term->esc_args[1], term->cfg.height)); } break; case 9: if (term->esc_nargs >= 2) - set_zoomed(term->esc_args[1] ? + set_zoomed(term->frontend, + term->esc_args[1] ? TRUE : FALSE); break; case 11: - ldisc_send(is_iconic() ? "\033[1t" : "\033[2t", - 4, 0); + if (term->ldisc) + ldisc_send(term->ldisc, + is_iconic(term->frontend) ? + "\033[1t" : "\033[2t", 4, 0); break; case 13: - get_window_pos(&x, &y); - len = sprintf(buf, "\033[3;%d;%dt", x, y); - ldisc_send(buf, len, 0); + if (term->ldisc) { + get_window_pos(term->frontend, &x, &y); + len = sprintf(buf, "\033[3;%d;%dt", x, y); + ldisc_send(term->ldisc, buf, len, 0); + } break; case 14: - get_window_pixels(&x, &y); - len = sprintf(buf, "\033[4;%d;%dt", x, y); - ldisc_send(buf, len, 0); + if (term->ldisc) { + get_window_pixels(term->frontend, &x, &y); + len = sprintf(buf, "\033[4;%d;%dt", x, y); + ldisc_send(term->ldisc, buf, len, 0); + } break; case 18: - len = sprintf(buf, "\033[8;%d;%dt", - term->rows, term->cols); - ldisc_send(buf, len, 0); + if (term->ldisc) { + len = sprintf(buf, "\033[8;%d;%dt", + term->rows, term->cols); + ldisc_send(term->ldisc, buf, len, 0); + } break; case 19: /* @@ -2194,18 +2599,22 @@ void term_out(Terminal *term) */ break; case 20: - p = get_window_title(TRUE); - len = strlen(p); - ldisc_send("\033]L", 3, 0); - ldisc_send(p, len, 0); - ldisc_send("\033\\", 2, 0); + if (term->ldisc) { + p = get_window_title(term->frontend, TRUE); + len = strlen(p); + ldisc_send(term->ldisc, "\033]L", 3, 0); + ldisc_send(term->ldisc, p, len, 0); + ldisc_send(term->ldisc, "\033\\", 2, 0); + } break; case 21: - p = get_window_title(FALSE); - len = strlen(p); - ldisc_send("\033]l", 3, 0); - ldisc_send(p, len, 0); - ldisc_send("\033\\", 2, 0); + if (term->ldisc) { + p = get_window_title(term->frontend,FALSE); + len = strlen(p); + ldisc_send(term->ldisc, "\033]l", 3, 0); + ldisc_send(term->ldisc, p, len, 0); + ldisc_send(term->ldisc, "\033\\", 2, 0); + } break; } } @@ -2234,10 +2643,10 @@ void term_out(Terminal *term) */ compatibility(VT420); if (term->esc_nargs == 1 && term->esc_args[0] > 0) { - if (!cfg.no_remote_resize) - request_resize(term->cols, + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, term->cols, def(term->esc_args[0], - cfg.height)); + term->cfg.height)); deselect(term); } break; @@ -2248,9 +2657,10 @@ void term_out(Terminal *term) */ compatibility(VT340TEXT); if (term->esc_nargs <= 1) { - if (!cfg.no_remote_resize) - request_resize(def(term->esc_args[0], - cfg.width), term->rows); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, + def(term->esc_args[0], + term->cfg.width), term->rows); deselect(term); } break; @@ -2265,6 +2675,8 @@ void term_out(Terminal *term) n = term->cols - term->curs.x; cursplus = term->curs; cursplus.x += n; + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+n, term->curs.y); check_selection(term, term->curs, cursplus); while (n--) *p++ = term->erase_char; @@ -2273,13 +2685,13 @@ void term_out(Terminal *term) break; case 'x': /* report terminal characteristics */ compatibility(VT100); - { + if (term->ldisc) { char buf[32]; int i = def(term->esc_args[0], 0); if (i == 0 || i == 1) { strcpy(buf, "\033[2;1;1;112;112;1;0x"); buf[2] += i; - ldisc_send(buf, 20, 0); + ldisc_send(term->ldisc, buf, 20, 0); } } break; @@ -2382,7 +2794,7 @@ void term_out(Terminal *term) * Well we should do a soft reset at this point ... */ if (!has_compat(VT420) && has_compat(VT100)) { - if (!cfg.no_remote_resize) { + if (!term->cfg.no_remote_resize) { if (term->reset_132) request_resize(132, 24); else @@ -2401,7 +2813,7 @@ void term_out(Terminal *term) term->osc_strlen = 0; break; case 'R': /* Linux palette reset */ - palette_reset(); + palette_reset(term->frontend); term_invalidate(term); term->termstate = TOPLEVEL; break; @@ -2447,7 +2859,7 @@ void term_out(Terminal *term) * * -- RDB */ - if (c == '\n' || c == '\r') { + if (c == '\012' || c == '\015') { term->termstate = TOPLEVEL; } else if (c == 0234 || c == '\007') { /* @@ -2480,7 +2892,7 @@ void term_out(Terminal *term) } term->osc_string[term->osc_strlen++] = val; if (term->osc_strlen >= 7) { - palette_set(term->osc_string[0], + palette_set(term->frontend, term->osc_string[0], term->osc_string[1] * 16 + term->osc_string[2], term->osc_string[3] * 16 + term->osc_string[4], term->osc_string[5] * 16 + term->osc_string[6]); @@ -2603,7 +3015,8 @@ void term_out(Terminal *term) term->termstate = VT52_Y1; break; case 'Z': - ldisc_send("\033/Z", 3, 0); + if (term->ldisc) + ldisc_send(term->ldisc, "\033/Z", 3, 0); break; case '=': term->app_keypad_keys = TRUE; @@ -2617,7 +3030,7 @@ void term_out(Terminal *term) * emulation. */ term->vt52_mode = FALSE; - term->blink_is_real = cfg.blinktext; + term->blink_is_real = term->cfg.blinktext; break; #if 0 case '^': @@ -2802,12 +3215,15 @@ static int linecmp(Terminal *term, unsigned long *a, unsigned long *b) */ static void do_paint(Terminal *term, Context ctx, int may_optimise) { - int i, j, our_curs_y; + int i, j, our_curs_y, our_curs_x; unsigned long rv, cursor; pos scrpos; char ch[1024]; long cursor_background = ERASE_CHAR; unsigned long ticks; +#ifdef OPTIMISE_SCROLL + struct scrollregion *sr; +#endif /* OPTIMISE_SCROLL */ /* * Check the visual bell state. @@ -2830,7 +3246,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) /* Has the cursor position or type changed ? */ if (term->cursor_on) { if (term->has_focus) { - if (term->blinker || !cfg.blink_cur) + if (term->blinker || !term->cfg.blink_cur) cursor = TATTR_ACTCURS; else cursor = 0; @@ -2841,13 +3257,27 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) } else cursor = 0; our_curs_y = term->curs.y - term->disptop; + { + /* + * Adjust the cursor position in the case where it's + * resting on the right-hand half of a CJK wide character. + * xterm's behaviour here, which seems adequate to me, is + * to display the cursor covering the _whole_ character, + * exactly as if it were one space to the left. + */ + unsigned long *ldata = lineptr(term->curs.y); + our_curs_x = term->curs.x; + if (our_curs_x > 0 && + (ldata[our_curs_x] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + our_curs_x--; + } if (term->dispcurs && (term->curstype != cursor || term->dispcurs != term->disptext + our_curs_y * (term->cols + 1) + - term->curs.x)) { + our_curs_x)) { if (term->dispcurs > term->disptext && - (*term->dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + (*term->dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE) term->dispcurs[-1] |= ATTR_INVALID; if ( (term->dispcurs[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) term->dispcurs[1] |= ATTR_INVALID; @@ -2856,6 +3286,18 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) } term->dispcurs = NULL; +#ifdef OPTIMISE_SCROLL + /* Do scrolls */ + sr = term->scrollhead; + while (sr) { + struct scrollregion *next = sr->next; + do_scroll(ctx, sr->topline, sr->botline, sr->lines); + sfree(sr); + sr = next; + } + term->scrollhead = term->scrolltail = NULL; +#endif /* OPTIMISE_SCROLL */ + /* The normal screen data */ for (i = 0; i < term->rows; i++) { unsigned long *ldata; @@ -2886,13 +3328,13 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) tattr = (*d & (ATTR_MASK ^ CSET_MASK)); switch (tchar & CSET_MASK) { case ATTR_ASCII: - tchar = unitab_line[tchar & 0xFF]; + tchar = term->ucsdata->unitab_line[tchar & 0xFF]; break; case ATTR_LINEDRW: - tchar = unitab_xterm[tchar & 0xFF]; + tchar = term->ucsdata->unitab_xterm[tchar & 0xFF]; break; case ATTR_SCOACS: - tchar = unitab_scoacs[tchar&0xFF]; + tchar = term->ucsdata->unitab_scoacs[tchar&0xFF]; break; } tattr |= (tchar & CSET_MASK); @@ -2916,9 +3358,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) /* 'Real' blinking ? */ if (term->blink_is_real && (tattr & ATTR_BLINK)) { if (term->has_focus && term->tblinker) { - tchar = ' '; - tattr &= ~CSET_MASK; - tattr |= ATTR_ACP; + tchar = term->ucsdata->unitab_line[(unsigned char)' ']; } tattr &= ~ATTR_BLINK; } @@ -2929,13 +3369,13 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) */ if ((tchar | tattr) != (term->disptext[idx]& ~ATTR_NARROW)) { if ((tattr & ATTR_WIDE) == 0 && - CharWidth(ctx, (tchar | tattr) & 0xFFFF) == 2) + char_width(ctx, (tchar | tattr) & 0xFFFF) == 2) tattr |= ATTR_NARROW; } else if (term->disptext[idx]&ATTR_NARROW) tattr |= ATTR_NARROW; /* Cursor here ? Save the 'background' */ - if (i == our_curs_y && j == term->curs.x) { + if (i == our_curs_y && j == our_curs_x) { cursor_background = tattr | tchar; term->dispcurs = term->disptext + idx; } @@ -2943,13 +3383,14 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) if ((term->disptext[idx] ^ tattr) & ATTR_WIDE) dirty_line = TRUE; - break_run = (tattr != attr || j - start >= sizeof(ch)); + break_run = (((tattr ^ attr) & term->attr_mask) || + j - start >= sizeof(ch)); /* Special hack for VT100 Linedraw glyphs */ if ((attr & CSET_MASK) == 0x2300 && tchar >= 0xBA && tchar <= 0xBD) break_run = TRUE; - if (!dbcs_screenfont && !dirty_line) { + if (!term->ucsdata->dbcs_screenfont && !dirty_line) { if ((tchar | tattr) == term->disptext[idx]) break_run = TRUE; else if (!dirty_run && ccount == 1) @@ -2964,7 +3405,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) start = j; ccount = 0; attr = tattr; - if (dbcs_screenfont) + if (term->ucsdata->dbcs_screenfont) last_run_dirty = dirty_run; dirty_run = dirty_line; } @@ -2979,11 +3420,12 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) if (++j < term->cols) { idx++; d++; - /* Cursor is here ? Ouch! */ - if (i == our_curs_y && j == term->curs.x) { - cursor_background = *d; - term->dispcurs = term->disptext + idx; - } + /* + * By construction above, the cursor should not + * be on the right-hand half of this character. + * Ever. + */ + assert(!(i == our_curs_y && j == our_curs_x)); if (term->disptext[idx] != *d) dirty_run = TRUE; term->disptext[idx] = *d; @@ -2999,7 +3441,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) if (i == our_curs_y && (term->curstype != cursor || updated_line)) { ch[0] = (char) (cursor_background & CHAR_MASK); attr = (cursor_background & ATTR_MASK) | cursor; - do_cursor(ctx, term->curs.x, i, ch, 1, attr, lattr); + do_cursor(ctx, our_curs_x, i, ch, 1, attr, lattr); term->curstype = cursor; } } @@ -3053,7 +3495,7 @@ void term_invalidate(Terminal *term) * Paint the window in response to a WM_PAINT message. */ void term_paint(Terminal *term, Context ctx, - int left, int top, int right, int bottom) + int left, int top, int right, int bottom, int immediately) { int i, j; if (left < 0) left = 0; @@ -3075,7 +3517,7 @@ void term_paint(Terminal *term, Context ctx, * fails to actually do anything when re-sizing ... painting the wrong * window perhaps ? */ - if (alt_pressed) + if (immediately) do_paint (term, ctx, FALSE); } @@ -3088,7 +3530,11 @@ void term_paint(Terminal *term, Context ctx, */ void term_scroll(Terminal *term, int rel, int where) { - int sbtop = -count234(term->scrollback); + int sbtop = -sblines(term); +#ifdef OPTIMISE_SCROLL + int olddisptop = term->disptop; + int shift; +#endif /* OPTIMISE_SCROLL */ term->disptop = (rel < 0 ? 0 : rel > 0 ? sbtop : term->disptop) + where; if (term->disptop < sbtop) @@ -3096,6 +3542,11 @@ void term_scroll(Terminal *term, int rel, int where) if (term->disptop > 0) term->disptop = 0; update_sbar(term); +#ifdef OPTIMISE_SCROLL + shift = (term->disptop - olddisptop); + if (shift < term->rows && shift > -term->rows) + scroll_display(term, 0, term->rows - 1, shift); +#endif /* OPTIMISE_SCROLL */ term_update(term); } @@ -3139,6 +3590,9 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) decpos(nlpos); if (poslt(nlpos, bottom)) nl = TRUE; + } else if (ldata[term->cols] & LATTR_WRAPPED2) { + /* Ignore the last char on the line in a WRAPPED2 line. */ + decpos(nlpos); } /* @@ -3170,23 +3624,23 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) switch (uc & CSET_MASK) { case ATTR_LINEDRW: - if (!cfg.rawcnp) { - uc = unitab_xterm[uc & 0xFF]; + if (!term->cfg.rawcnp) { + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; break; } case ATTR_ASCII: - uc = unitab_line[uc & 0xFF]; + uc = term->ucsdata->unitab_line[uc & 0xFF]; break; case ATTR_SCOACS: - uc = unitab_scoacs[uc&0xFF]; + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; break; } switch (uc & CSET_MASK) { case ATTR_ACP: - uc = unitab_font[uc & 0xFF]; + uc = term->ucsdata->unitab_font[uc & 0xFF]; break; case ATTR_OEMCP: - uc = unitab_oemcp[uc & 0xFF]; + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; break; } @@ -3197,17 +3651,17 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) if (DIRECT_FONT(uc)) { if (c >= ' ' && c != 0x7F) { - unsigned char buf[4]; + char buf[4]; WCHAR wbuf[4]; int rv; - if (is_dbcs_leadbyte(font_codepage, (BYTE) c)) { + if (is_dbcs_leadbyte(term->ucsdata->font_codepage, (BYTE) c)) { buf[0] = c; - buf[1] = (unsigned char) ldata[top.x + 1]; - rv = mb_to_wc(font_codepage, 0, buf, 2, wbuf, 4); + buf[1] = (char) (0xFF & ldata[top.x + 1]); + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 2, wbuf, 4); top.x++; } else { buf[0] = c; - rv = mb_to_wc(font_codepage, 0, buf, 1, wbuf, 4); + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 1, wbuf, 4); } if (rv > 0) { @@ -3245,7 +3699,7 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) wblen++; *wbptr++ = 0; #endif - write_clip(workbuf, wblen, FALSE); /* transfer to clipboard */ + write_clip(term->frontend, workbuf, wblen, FALSE); /* transfer to clipbd */ if (buflen > 0) /* indicates we allocated this buffer */ sfree(workbuf); } @@ -3253,7 +3707,7 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) void term_copyall(Terminal *term) { pos top; - top.y = -count234(term->scrollback); + top.y = -sblines(term); top.x = 0; clipme(term, top, term->curs, 0); } @@ -3264,9 +3718,10 @@ void term_copyall(Terminal *term) */ static int wordtype(Terminal *term, int uc) { - static struct { + struct ucsword { int start, end, ctype; - } *wptr, ucs_words[] = { + }; + static const struct ucsword ucs_words[] = { { 128, 160, 0}, { 161, 191, 1}, { @@ -3330,33 +3785,35 @@ static int wordtype(Terminal *term, int uc) { 0, 0, 0} }; + const struct ucsword *wptr; uc &= (CSET_MASK | CHAR_MASK); switch (uc & CSET_MASK) { case ATTR_LINEDRW: - uc = unitab_xterm[uc & 0xFF]; + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; break; case ATTR_ASCII: - uc = unitab_line[uc & 0xFF]; + uc = term->ucsdata->unitab_line[uc & 0xFF]; break; case ATTR_SCOACS: - uc = unitab_scoacs[uc&0xFF]; + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; break; } switch (uc & CSET_MASK) { case ATTR_ACP: - uc = unitab_font[uc & 0xFF]; + uc = term->ucsdata->unitab_font[uc & 0xFF]; break; case ATTR_OEMCP: - uc = unitab_oemcp[uc & 0xFF]; + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; break; } /* For DBCS font's I can't do anything usefull. Even this will sometimes * fail as there's such a thing as a double width space. :-( */ - if (dbcs_screenfont && font_codepage == line_codepage) + if (term->ucsdata->dbcs_screenfont && + term->ucsdata->font_codepage == term->ucsdata->line_codepage) return (uc != ' '); if (uc < 0x80) @@ -3377,7 +3834,7 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) { unsigned long *ldata; short wvalue; - int topy = -count234(term->scrollback); + int topy = -sblines(term); ldata = lineptr(p.y); @@ -3402,11 +3859,13 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) * In this mode, the units are maximal runs of characters * whose `wordness' has the same value. */ - wvalue = wordtype(term, ldata[p.x]); + wvalue = wordtype(term, UCSGET(ldata, p.x)); if (dir == +1) { while (1) { - if (p.x < term->cols-1) { - if (wordtype(term, ldata[p.x + 1]) == wvalue) + int maxcols = (ldata[term->cols] & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (p.x < maxcols-1) { + if (wordtype(term, UCSGET(ldata, p.x + 1)) == wvalue) p.x++; else break; @@ -3414,7 +3873,7 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) if (ldata[term->cols] & LATTR_WRAPPED) { unsigned long *ldata2; ldata2 = lineptr(p.y+1); - if (wordtype(term, ldata2[0]) == wvalue) { + if (wordtype(term, UCSGET(ldata2, 0)) == wvalue) { p.x = 0; p.y++; ldata = ldata2; @@ -3427,20 +3886,26 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) } else { while (1) { if (p.x > 0) { - if (wordtype(term, ldata[p.x - 1]) == wvalue) + if (wordtype(term, UCSGET(ldata, p.x - 1)) == wvalue) p.x--; else break; } else { unsigned long *ldata2; + int maxcols; if (p.y <= topy) break; ldata2 = lineptr(p.y-1); - if ((ldata2[term->cols] & LATTR_WRAPPED) && - wordtype(term, ldata2[term->cols-1]) == wvalue) { - p.x = term->cols-1; - p.y--; - ldata = ldata2; + maxcols = (ldata2[term->cols] & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (ldata2[term->cols] & LATTR_WRAPPED) { + if (wordtype(term, UCSGET(ldata2, maxcols-1)) + == wvalue) { + p.x = maxcols-1; + p.y--; + ldata = ldata2; + } else + break; } else break; } @@ -3472,7 +3937,7 @@ void term_do_paste(Terminal *term) wchar_t *data; int len; - get_clip(&data, &len); + get_clip(term->frontend, &data, &len); if (data && len > 0) { wchar_t *p, *q; @@ -3499,7 +3964,7 @@ void term_do_paste(Terminal *term) if (p <= data + len - sel_nl_sz && !memcmp(p, sel_nl, sizeof(sel_nl))) { - term->paste_buffer[term->paste_len++] = '\r'; + term->paste_buffer[term->paste_len++] = '\015'; p += sel_nl_sz; } q = p; @@ -3507,24 +3972,25 @@ void term_do_paste(Terminal *term) /* Assume a small paste will be OK in one go. */ if (term->paste_len < 256) { - luni_send(term->paste_buffer, term->paste_len, 0); + if (term->ldisc) + luni_send(term->ldisc, term->paste_buffer, term->paste_len, 0); if (term->paste_buffer) sfree(term->paste_buffer); term->paste_buffer = 0; term->paste_pos = term->paste_hold = term->paste_len = 0; } } - get_clip(NULL, NULL); + get_clip(term->frontend, NULL, NULL); } -void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, - int shift, int ctrl, int alt) +void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked, + Mouse_Action a, int x, int y, int shift, int ctrl, int alt) { pos selpoint; unsigned long *ldata; int raw_mouse = (term->xterm_mouse && - !cfg.no_mouse_rep && - !(cfg.mouse_override && shift)); + !term->cfg.no_mouse_rep && + !(term->cfg.mouse_override && shift)); int default_seltype; if (y < 0) { @@ -3556,62 +4022,62 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, if (raw_mouse) { int encstate = 0, r, c; char abuf[16]; - static int is_down = 0; - switch (b) { - case MBT_LEFT: - encstate = 0x20; /* left button down */ - break; - case MBT_MIDDLE: - encstate = 0x21; - break; - case MBT_RIGHT: - encstate = 0x22; - break; - case MBT_WHEEL_UP: - encstate = 0x60; - break; - case MBT_WHEEL_DOWN: - encstate = 0x61; - break; - default: break; /* placate gcc warning about enum use */ - } - switch (a) { - case MA_DRAG: - if (term->xterm_mouse == 1) - return; - encstate += 0x20; - break; - case MA_RELEASE: - encstate = 0x23; - is_down = 0; - break; - case MA_CLICK: - if (is_down == b) - return; - is_down = b; - break; - default: break; /* placate gcc warning about enum use */ + if (term->ldisc) { + + switch (braw) { + case MBT_LEFT: + encstate = 0x20; /* left button down */ + break; + case MBT_MIDDLE: + encstate = 0x21; + break; + case MBT_RIGHT: + encstate = 0x22; + break; + case MBT_WHEEL_UP: + encstate = 0x60; + break; + case MBT_WHEEL_DOWN: + encstate = 0x61; + break; + default: break; /* placate gcc warning about enum use */ + } + switch (a) { + case MA_DRAG: + if (term->xterm_mouse == 1) + return; + encstate += 0x20; + break; + case MA_RELEASE: + encstate = 0x23; + term->mouse_is_down = 0; + break; + case MA_CLICK: + if (term->mouse_is_down == braw) + return; + term->mouse_is_down = braw; + break; + default: break; /* placate gcc warning about enum use */ + } + if (shift) + encstate += 0x04; + if (ctrl) + encstate += 0x10; + r = y + 33; + c = x + 33; + + sprintf(abuf, "\033[M%c%c%c", encstate, c, r); + ldisc_send(term->ldisc, abuf, 6, 0); } - if (shift) - encstate += 0x04; - if (ctrl) - encstate += 0x10; - r = y + 33; - c = x + 33; - - sprintf(abuf, "\033[M%c%c%c", encstate, c, r); - ldisc_send(abuf, 6, 0); return; } - b = translate_button(b); - /* * Set the selection type (rectangular or normal) at the start * of a selection attempt, from the state of Alt. */ - if (!alt ^ !cfg.rect_select) + if (!alt ^ !term->cfg.rect_select) default_seltype = RECTANGULAR; else default_seltype = LEXICOGRAPHIC; @@ -3620,13 +4086,13 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->seltype = default_seltype; } - if (b == MBT_SELECT && a == MA_CLICK) { + if (bcooked == MBT_SELECT && a == MA_CLICK) { deselect(term); term->selstate = ABOUT_TO; term->seltype = default_seltype; term->selanchor = selpoint; term->selmode = SM_CHAR; - } else if (b == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) { + } else if (bcooked == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) { deselect(term); term->selmode = (a == MA_2CLK ? SM_WORD : SM_LINE); term->selstate = DRAGGING; @@ -3634,11 +4100,12 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->selend = term->selstart; incpos(term->selend); sel_spread(term); - } else if ((b == MBT_SELECT && a == MA_DRAG) || - (b == MBT_EXTEND && a != MA_RELEASE)) { + } else if ((bcooked == MBT_SELECT && a == MA_DRAG) || + (bcooked == MBT_EXTEND && a != MA_RELEASE)) { if (term->selstate == ABOUT_TO && poseq(term->selanchor, selpoint)) return; - if (b == MBT_EXTEND && a != MA_DRAG && term->selstate == SELECTED) { + if (bcooked == MBT_EXTEND && a != MA_DRAG && + term->selstate == SELECTED) { if (term->seltype == LEXICOGRAPHIC) { /* * For normal selection, we extend by moving @@ -3699,7 +4166,8 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->selend.y = max(term->selanchor.y, selpoint.y); } sel_spread(term); - } else if ((b == MBT_SELECT || b == MBT_EXTEND) && a == MA_RELEASE) { + } else if ((bcooked == MBT_SELECT || bcooked == MBT_EXTEND) && + a == MA_RELEASE) { if (term->selstate == DRAGGING) { /* * We've completed a selection. We now transfer the @@ -3710,18 +4178,458 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->selstate = SELECTED; } else term->selstate = NO_SELECTION; - } else if (b == MBT_PASTE + } else if (bcooked == MBT_PASTE && (a == MA_CLICK #if MULTICLICK_ONLY_EVENT || a == MA_2CLK || a == MA_3CLK #endif )) { - request_paste(); + request_paste(term->frontend); } term_update(term); } +void term_key(Terminal *term, Key_Sym keysym, wchar_t *text, size_t tlen, + unsigned int modifiers, unsigned int flags) +{ + char output[10]; + char *p = output; + int prependesc = FALSE; +#if 0 + int i; + + fprintf(stderr, "keysym = %d, %d chars:", keysym, tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", (unsigned)text[i]); + fprintf(stderr, "\n"); +#endif + + /* XXX Num Lock */ + if ((flags & PKF_REPEAT) && term->repeat_off) + return; + + /* Currently, Meta always just prefixes everything with ESC. */ + if (modifiers & PKM_META) + prependesc = TRUE; + modifiers &= ~PKM_META; + + /* + * Alt is only used for Alt+keypad, which isn't supported yet, so + * ignore it. + */ + modifiers &= ~PKM_ALT; + + /* Standard local function keys */ + switch (modifiers & (PKM_SHIFT | PKM_CONTROL)) { + case PKM_SHIFT: + if (keysym == PK_PAGEUP) + /* scroll up one page */; + if (keysym == PK_PAGEDOWN) + /* scroll down on page */; + if (keysym == PK_INSERT) + term_do_paste(term); + break; + case PKM_CONTROL: + if (keysym == PK_PAGEUP) + /* scroll up one line */; + if (keysym == PK_PAGEDOWN) + /* scroll down one line */; + /* Control-Numlock for app-keypad mode switch */ + if (keysym == PK_PF1) + term->app_keypad_keys ^= 1; + break; + } + + if (modifiers & PKM_ALT) { + /* Alt+F4 (close) */ + /* Alt+Return (full screen) */ + /* Alt+Space (system menu) */ + } + + if (keysym == PK_NULL && (modifiers & PKM_CONTROL) && tlen == 1 && + text[0] >= 0x20 && text[0] <= 0x7e) { + /* ASCII chars + Control */ + if ((text[0] >= 0x40 && text[0] <= 0x5f) || + (text[0] >= 0x61 && text[0] <= 0x7a)) + text[0] &= 0x1f; + else { + /* + * Control-2 should return ^@ (0x00), Control-6 should return + * ^^ (0x1E), and Control-Minus should return ^_ (0x1F). Since + * the DOS keyboard handling did it, and we have nothing better + * to do with the key combo in question, we'll also map + * Control-Backquote to ^\ (0x1C). + */ + switch (text[0]) { + case ' ': text[0] = 0x00; break; + case '-': text[0] = 0x1f; break; + case '/': text[0] = 0x1f; break; + case '2': text[0] = 0x00; break; + case '3': text[0] = 0x1b; break; + case '4': text[0] = 0x1c; break; + case '5': text[0] = 0x1d; break; + case '6': text[0] = 0x1e; break; + case '7': text[0] = 0x1f; break; + case '8': text[0] = 0x7f; break; + case '`': text[0] = 0x1c; break; + } + } + } + + /* Nethack keypad */ + if (term->cfg.nethack_keypad) { + char c = 0; + switch (keysym) { + case PK_KP1: c = 'b'; break; + case PK_KP2: c = 'j'; break; + case PK_KP3: c = 'n'; break; + case PK_KP4: c = 'h'; break; + case PK_KP5: c = '.'; break; + case PK_KP6: c = 'l'; break; + case PK_KP7: c = 'y'; break; + case PK_KP8: c = 'k'; break; + case PK_KP9: c = 'u'; break; + default: break; /* else gcc warns `enum value not used' */ + } + if (c != 0) { + if (c != '.') { + if (modifiers & PKM_CONTROL) + c &= 0x1f; + else if (modifiers & PKM_SHIFT) + c = toupper(c); + } + *p++ = c; + goto done; + } + } + + /* Numeric Keypad */ + if (PK_ISKEYPAD(keysym)) { + int xkey = 0; + + /* + * In VT400 mode, PFn always emits an escape sequence. In + * Linux and tilde modes, this only happens in app keypad mode. + */ + if (term->cfg.funky_type == FUNKY_VT400 || + ((term->cfg.funky_type == FUNKY_LINUX || + term->cfg.funky_type == FUNKY_TILDE) && + term->app_keypad_keys && !term->cfg.no_applic_k)) { + switch (keysym) { + case PK_PF1: xkey = 'P'; break; + case PK_PF2: xkey = 'Q'; break; + case PK_PF3: xkey = 'R'; break; + case PK_PF4: xkey = 'S'; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + if (term->app_keypad_keys && !term->cfg.no_applic_k) { + switch (keysym) { + case PK_KP0: xkey = 'p'; break; + case PK_KP1: xkey = 'q'; break; + case PK_KP2: xkey = 'r'; break; + case PK_KP3: xkey = 's'; break; + case PK_KP4: xkey = 't'; break; + case PK_KP5: xkey = 'u'; break; + case PK_KP6: xkey = 'v'; break; + case PK_KP7: xkey = 'w'; break; + case PK_KP8: xkey = 'x'; break; + case PK_KP9: xkey = 'y'; break; + case PK_KPDECIMAL: xkey = 'n'; break; + case PK_KPENTER: xkey = 'M'; break; + default: break; /* else gcc warns `enum value not used' */ + } + if (term->cfg.funky_type == FUNKY_XTERM && tlen > 0) { + /* + * xterm can't see the layout of the keypad, so it has + * to rely on the X keysyms returned by the keys. + * Hence, we look at the strings here, not the PuTTY + * keysyms (which describe the layout). + */ + switch (text[0]) { + case '+': + if (modifiers & PKM_SHIFT) + xkey = 'l'; + else + xkey = 'k'; + break; + case '/': xkey = 'o'; break; + case '*': xkey = 'j'; break; + case '-': xkey = 'm'; break; + } + } else { + /* + * In all other modes, we try to retain the layout of + * the DEC keypad in application mode. + */ + switch (keysym) { + case PK_KPBIGPLUS: + /* This key covers the '-' and ',' keys on a VT220 */ + if (modifiers & PKM_SHIFT) + xkey = 'm'; /* VT220 '-' */ + else + xkey = 'l'; /* VT220 ',' */ + break; + case PK_KPMINUS: xkey = 'm'; break; + case PK_KPCOMMA: xkey = 'l'; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + } + if (xkey) { + if (term->vt52_mode) { + if (xkey >= 'P' && xkey <= 'S') + p += sprintf((char *) p, "\x1B%c", xkey); + else + p += sprintf((char *) p, "\x1B?%c", xkey); + } else + p += sprintf((char *) p, "\x1BO%c", xkey); + goto done; + } + /* Not in application mode -- treat the number pad as arrow keys? */ + if ((flags & PKF_NUMLOCK) == 0) { + switch (keysym) { + case PK_KP0: keysym = PK_INSERT; break; + case PK_KP1: keysym = PK_END; break; + case PK_KP2: keysym = PK_DOWN; break; + case PK_KP3: keysym = PK_PAGEDOWN; break; + case PK_KP4: keysym = PK_LEFT; break; + case PK_KP5: keysym = PK_REST; break; + case PK_KP6: keysym = PK_RIGHT; break; + case PK_KP7: keysym = PK_HOME; break; + case PK_KP8: keysym = PK_UP; break; + case PK_KP9: keysym = PK_PAGEUP; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + } + + /* Miscellaneous keys */ + switch (keysym) { + case PK_ESCAPE: + *p++ = 0x1b; + goto done; + case PK_BACKSPACE: + if (modifiers == 0) + *p++ = (term->cfg.bksp_is_delete ? 0x7F : 0x08); + else if (modifiers == PKM_SHIFT) + /* We do the opposite of what is configured */ + *p++ = (term->cfg.bksp_is_delete ? 0x08 : 0x7F); + else break; + goto done; + case PK_TAB: + if (modifiers == 0) + *p++ = 0x09; + else if (modifiers == PKM_SHIFT) + *p++ = 0x1B, *p++ = '[', *p++ = 'Z'; + else break; + goto done; + /* XXX window.c has ctrl+shift+space sending 0xa0 */ + case PK_PAUSE: + if (modifiers == PKM_CONTROL) + *p++ = 26; + else break; + goto done; + case PK_RETURN: + case PK_KPENTER: /* Odd keypad modes handled above */ + if (modifiers == 0) { + *p++ = 0x0d; + if (term->cr_lf_return) + *p++ = 0x0a; + goto done; + } + default: break; /* else gcc warns `enum value not used' */ + } + + /* SCO function keys and editing keys */ + if (term->cfg.funky_type == FUNKY_SCO) { + if (PK_ISFKEY(keysym) && keysym <= PK_F12) { + static char const codes[] = + "MNOPQRSTUVWX" "YZabcdefghij" "klmnopqrstuv" "wxyz@[\\]^_`{"; + int index = keysym - PK_F1; + + if (modifiers & PKM_SHIFT) index += 12; + if (modifiers & PKM_CONTROL) index += 24; + p += sprintf((char *) p, "\x1B[%c", codes[index]); + goto done; + } + if (PK_ISEDITING(keysym)) { + int xkey = 0; + + switch (keysym) { + case PK_DELETE: *p++ = 0x7f; goto done; + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_END: xkey = 'F'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + default: break; /* else gcc warns `enum value not used' */ + } + p += sprintf((char *) p, "\x1B[%c", xkey); + } + } + + if (PK_ISEDITING(keysym) && (modifiers & PKM_SHIFT) == 0) { + int code; + + if (term->cfg.funky_type == FUNKY_XTERM) { + /* Xterm shuffles these keys, apparently. */ + switch (keysym) { + case PK_HOME: keysym = PK_INSERT; break; + case PK_INSERT: keysym = PK_HOME; break; + case PK_DELETE: keysym = PK_END; break; + case PK_END: keysym = PK_PAGEUP; break; + case PK_PAGEUP: keysym = PK_DELETE; break; + case PK_PAGEDOWN: keysym = PK_PAGEDOWN; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + + /* RXVT Home/End */ + if (term->cfg.rxvt_homeend && + (keysym == PK_HOME || keysym == PK_END)) { + p += sprintf((char *) p, keysym == PK_HOME ? "\x1B[H" : "\x1BOw"); + goto done; + } + + if (term->vt52_mode) { + int xkey; + + /* + * A real VT52 doesn't have these, and a VT220 doesn't + * send anything for them in VT52 mode. + */ + switch (keysym) { + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_DELETE: xkey = 'M'; break; + case PK_END: xkey = 'E'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + default: break; /* else gcc warns `enum value not used' */ + } + p += sprintf((char *) p, "\x1B%c", xkey); + goto done; + } + + switch (keysym) { + case PK_HOME: code = 1; break; + case PK_INSERT: code = 2; break; + case PK_DELETE: code = 3; break; + case PK_END: code = 4; break; + case PK_PAGEUP: code = 5; break; + case PK_PAGEDOWN: code = 6; break; + default: break; /* else gcc warns `enum value not used' */ + } + p += sprintf((char *) p, "\x1B[%d~", code); + goto done; + } + + if (PK_ISFKEY(keysym)) { + /* Map Shift+F1-F10 to F11-F20 */ + if (keysym >= PK_F1 && keysym <= PK_F10 && (modifiers & PKM_SHIFT)) + keysym += 10; + if ((term->vt52_mode || term->cfg.funky_type == FUNKY_VT100P) && + keysym <= PK_F14) { + /* XXX This overrides the XTERM/VT52 mode below */ + int offt = 0; + if (keysym >= PK_F6) offt++; + if (keysym >= PK_F12) offt++; + p += sprintf((char *) p, term->vt52_mode ? "\x1B%c" : "\x1BO%c", + 'P' + keysym - PK_F1 - offt); + goto done; + } + if (term->cfg.funky_type == FUNKY_LINUX && keysym <= PK_F5) { + p += sprintf((char *) p, "\x1B[[%c", 'A' + keysym - PK_F1); + goto done; + } + if (term->cfg.funky_type == FUNKY_XTERM && keysym <= PK_F4) { + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", 'P' + keysym - PK_F1); + else + p += sprintf((char *) p, "\x1BO%c", 'P' + keysym - PK_F1); + goto done; + } + p += sprintf((char *) p, "\x1B[%d~", 11 + keysym - PK_F1); + goto done; + } + + if (PK_ISCURSOR(keysym)) { + int xkey; + + switch (keysym) { + case PK_UP: xkey = 'A'; break; + case PK_DOWN: xkey = 'B'; break; + case PK_RIGHT: xkey = 'C'; break; + case PK_LEFT: xkey = 'D'; break; + case PK_REST: xkey = 'G'; break; /* centre key on number pad */ + default: break; /* else gcc warns `enum value not used' */ + } + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", xkey); + else { + int app_flg = (term->app_cursor_keys && !term->cfg.no_applic_c); + + /* Useful mapping of Ctrl-arrows */ + if (modifiers == PKM_CONTROL) + app_flg = !app_flg; + + if (app_flg) + p += sprintf((char *) p, "\x1BO%c", xkey); + else + p += sprintf((char *) p, "\x1B[%c", xkey); + } + goto done; + } + + done: + if (p > output || tlen > 0) { + /* + * Interrupt an ongoing paste. I'm not sure + * this is sensible, but for the moment it's + * preferable to having to faff about buffering + * things. + */ + term_nopaste(term); + + /* + * We need not bother about stdin backlogs + * here, because in GUI PuTTY we can't do + * anything about it anyway; there's no means + * of asking Windows to hold off on KEYDOWN + * messages. We _have_ to buffer everything + * we're sent. + */ + term_seen_key_event(term); + + if (prependesc) { +#if 0 + fprintf(stderr, "sending ESC\n"); +#endif + ldisc_send(term->ldisc, "\x1b", 1, 1); + } + + if (p > output) { +#if 0 + fprintf(stderr, "sending %d bytes:", p - output); + for (i = 0; i < p - output; i++) + fprintf(stderr, " %02x", output[i]); + fprintf(stderr, "\n"); +#endif + ldisc_send(term->ldisc, output, p - output, 1); + } else if (tlen > 0) { +#if 0 + fprintf(stderr, "sending %d unichars:", tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", (unsigned) text[i]); + fprintf(stderr, "\n"); +#endif + luni_send(term->ldisc, text, tlen, 1); + } + } +} + void term_nopaste(Terminal *term) { if (term->paste_len == 0) @@ -3755,10 +4663,11 @@ void term_paste(Terminal *term) while (term->paste_pos < term->paste_len) { int n = 0; while (n + term->paste_pos < term->paste_len) { - if (term->paste_buffer[term->paste_pos + n++] == '\r') + if (term->paste_buffer[term->paste_pos + n++] == '\015') break; } - luni_send(term->paste_buffer + term->paste_pos, n, 0); + if (term->ldisc) + luni_send(term->ldisc, term->paste_buffer + term->paste_pos, n, 0); term->paste_pos += n; if (term->paste_pos < term->paste_len) { @@ -3795,7 +4704,7 @@ int term_ldisc(Terminal *term, int option) /* * from_backend(), to get data from the backend for the terminal. */ -int from_backend(void *vterm, int is_stderr, char *data, int len) +int from_backend(void *vterm, int is_stderr, const char *data, int len) { Terminal *term = (Terminal *)vterm; @@ -3824,3 +4733,8 @@ int from_backend(void *vterm, int is_stderr, char *data, int len) */ return 0; } + +void term_provide_logctx(Terminal *term, void *logctx) +{ + term->logctx = logctx; +}