+/*
+ * Terminal emulator.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define TM_PUTTY (0xFFFF)
+#define UPDATE_DELAY ((TICKSPERSEC+49)/50)/* ticks to defer window update */
+#define TBLINK_DELAY ((TICKSPERSEC*9+19)/20)/* ticks between text blinks*/
+#define CBLINK_DELAY (CURSORBLINK) /* ticks between cursor blinks */
+#define VBELL_DELAY (VBELL_TIMEOUT) /* visual bell timeout in ticks */
+
#define compatibility(x) \
if ( ((CL_##x)&term->compatibility_level) == 0 ) { \
term->termstate=TOPLEVEL; \
#define has_compat(x) ( ((CL_##x)&term->compatibility_level) != 0 )
+char *EMPTY_WINDOW_TITLE = "";
+
const char sco2ansicolour[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
#define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t))
static void unlineptr(termline *);
static void do_paint(Terminal *, Context, int);
static void erase_lots(Terminal *, int, int, int);
+static int find_last_nonempty_line(Terminal *, tree234 *);
static void swap_screen(Terminal *, int, int, int);
static void update_sbar(Terminal *);
static void deselect(Terminal *);
static void term_print_finish(Terminal *);
+static void scroll(Terminal *, int, int, int, int);
#ifdef OPTIMISE_SCROLL
static void scroll_display(Terminal *, int, int, int);
#endif /* OPTIMISE_SCROLL */
freeline(line);
}
+#ifdef TERM_CC_DIAGS
/*
* Diagnostic function: verify that a termline has a correct
* combining character structure.
*
- * XXX-REMOVE-BEFORE-RELEASE: This is a performance-intensive
- * check. Although it's currently really useful for getting all the
- * bugs out of the new cc stuff, it will want to be absent when we
- * make a proper release.
+ * This is a performance-intensive check, so it's no longer enabled
+ * by default.
*/
static void cc_check(termline *line)
{
j += (flags[i] != 0);
assert(j == line->size);
+
+ sfree(flags);
}
+#endif
/*
* Add a combining character to a character cell.
line->chars[newcc].chr = chr;
line->chars[col].cc_next = newcc - col;
- cc_check(line); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
}
/*
line->chars[origcol].cc_next = 0;
- cc_check(line); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
}
/*
/* FULL-TERMCHAR */
if (a->chr != bchr)
return FALSE;
- if (a->attr != battr)
+ if ((a->attr &~ DATTR_MASK) != (battr &~ DATTR_MASK))
return FALSE;
while (a->cc_next || b->cc_next) {
if (!a->cc_next || !b->cc_next)
add_cc(destline, x, src->chr);
}
- cc_check(destline); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(destline);
+#endif
}
/*
/* Ensure the original cell doesn't have a cc list. */
src->cc_next = 0;
- cc_check(line); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
}
/*
hdrpos = b->len;
hdrsize = 0;
add(b, 0);
+ /* And ensure this run doesn't interfere with the next. */
+ prevlen = prevpos = 0;
+ prev2 = FALSE;
continue;
} else {
* store a two-byte value with the top bit clear (indicating
* just that value), or a four-byte value with the top bit set
* (indicating the same value with its top bit clear).
+ *
+ * However, first I permute the bits of the attribute value, so
+ * that the eight bits of colour (four in each of fg and bg)
+ * which are never non-zero unless xterm 256-colour mode is in
+ * use are placed higher up the word than everything else. This
+ * ensures that attribute values remain 16-bit _unless_ the
+ * user uses extended colour.
*/
- if (c->attr < 0x8000) {
- add(b, (unsigned char)((c->attr >> 8) & 0xFF));
- add(b, (unsigned char)(c->attr & 0xFF));
+ unsigned attr, colourbits;
+
+ attr = c->attr;
+
+ assert(ATTR_BGSHIFT > ATTR_FGSHIFT);
+
+ colourbits = (attr >> (ATTR_BGSHIFT + 4)) & 0xF;
+ colourbits <<= 4;
+ colourbits |= (attr >> (ATTR_FGSHIFT + 4)) & 0xF;
+
+ attr = (((attr >> (ATTR_BGSHIFT + 8)) << (ATTR_BGSHIFT + 4)) |
+ (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));
+ attr = (((attr >> (ATTR_FGSHIFT + 8)) << (ATTR_FGSHIFT + 4)) |
+ (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));
+
+ attr |= (colourbits << (32-9));
+
+ if (attr < 0x8000) {
+ add(b, (unsigned char)((attr >> 8) & 0xFF));
+ add(b, (unsigned char)(attr & 0xFF));
} else {
- add(b, (unsigned char)(((c->attr >> 24) & 0x7F) | 0x80));
- add(b, (unsigned char)((c->attr >> 16) & 0xFF));
- add(b, (unsigned char)((c->attr >> 8) & 0xFF));
- add(b, (unsigned char)(c->attr & 0xFF));
+ add(b, (unsigned char)(((attr >> 24) & 0x7F) | 0x80));
+ add(b, (unsigned char)((attr >> 16) & 0xFF));
+ add(b, (unsigned char)((attr >> 8) & 0xFF));
+ add(b, (unsigned char)(attr & 0xFF));
}
}
static void makeliteral_cc(struct buf *b, termchar *c, unsigned long *state)
/*
* Diagnostics: ensure that the compressed data really does
* decompress to the right thing.
+ *
+ * This is a bit performance-heavy for production code.
*/
+#ifdef TERM_CC_DIAGS
#ifndef CHECK_SB_COMPRESSION
{
int dused;
freeline(dcl);
}
#endif
+#endif /* TERM_CC_DIAGS */
/*
* Trim the allocated memory so we don't waste any, and return.
static void readliteral_attr(struct buf *b, termchar *c, termline *ldata,
unsigned long *state)
{
- int val;
+ unsigned val, attr, colourbits;
val = get(b) << 8;
val |= get(b);
if (val >= 0x8000) {
+ val &= ~0x8000;
val <<= 16;
val |= get(b) << 8;
val |= get(b);
}
- c->attr = val;
+ colourbits = (val >> (32-9)) & 0xFF;
+ attr = (val & ((1<<(32-9))-1));
+
+ attr = (((attr >> (ATTR_FGSHIFT + 4)) << (ATTR_FGSHIFT + 8)) |
+ (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));
+ attr = (((attr >> (ATTR_BGSHIFT + 4)) << (ATTR_BGSHIFT + 8)) |
+ (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));
+
+ attr |= (colourbits >> 4) << (ATTR_BGSHIFT + 4);
+ attr |= (colourbits & 0xF) << (ATTR_FGSHIFT + 4);
+
+ c->attr = attr;
}
static void readliteral_cc(struct buf *b, termchar *c, termline *ldata,
unsigned long *state)
*/
static void resizeline(Terminal *term, termline *line, int cols)
{
- int i, oldlen;
+ int i, oldcols;
if (line->cols != cols) {
+
+ oldcols = line->cols;
+
/*
* This line is the wrong length, which probably means it
* hasn't been accessed since a resize. Resize it now.
* out in the resize (if we're shrinking the line) and
* return their cc lists to the cc free list.
*/
- for (i = cols; i < line->cols; i++)
+ for (i = cols; i < oldcols; i++)
clear_cc(line, i);
/*
+ * If we're shrinking the line, we now bodily move the
+ * entire cc section from where it started to where it now
+ * needs to be. (We have to do this before the resize, so
+ * that the data we're copying is still there. However, if
+ * we're expanding, we have to wait until _after_ the
+ * resize so that the space we're copying into is there.)
+ */
+ if (cols < oldcols)
+ memmove(line->chars + cols, line->chars + oldcols,
+ (line->size - line->cols) * TSIZE);
+
+ /*
* Now do the actual resize, leaving the _same_ amount of
* cc space as there was to begin with.
*/
- oldlen = line->cols;
- line->size += cols - oldlen;
+ line->size += cols - oldcols;
line->chars = sresize(line->chars, line->size, TTYPE);
line->cols = cols;
/*
- * Bodily move the entire cc section from where it started
- * to where it now needs to be.
+ * If we're expanding the line, _now_ we move the cc
+ * section.
*/
- memmove(line->chars + line->cols, line->chars + oldlen,
- (line->size - line->cols) * TSIZE);
+ if (cols > oldcols)
+ memmove(line->chars + cols, line->chars + oldcols,
+ (line->size - line->cols) * TSIZE);
/*
* Go through what's left of the original line, and adjust
* relative offsets within the cc block.) Also do the same
* to the head of the cc_free list.
*/
- for (i = 0; i < oldlen && i < line->cols; i++)
+ for (i = 0; i < oldcols && i < cols; i++)
if (line->chars[i].cc_next)
- line->chars[i].cc_next += cols - oldlen;
+ line->chars[i].cc_next += cols - oldcols;
if (line->cc_free)
- line->cc_free += cols - oldlen;
+ line->cc_free += cols - oldcols;
/*
* And finally fill in the new space with erase chars. (We
* don't have to worry about cc lists here, because we
* _know_ the erase char doesn't have one.)
*/
- for (i = oldlen; i < cols; i++)
+ for (i = oldcols; i < cols; i++)
line->chars[i] = term->basic_erase_char;
- cc_check(line); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
}
}
}
/* We assume that we don't screw up and retrieve something out of range. */
+ if (line == NULL) {
+ fatalbox("line==NULL in terminal.c\n"
+ "lineno=%d y=%d w=%d h=%d\n"
+ "count(scrollback=%p)=%d\n"
+ "count(screen=%p)=%d\n"
+ "count(alt=%p)=%d alt_sblines=%d\n"
+ "whichtree=%p treeindex=%d\n\n"
+ "Please contact <putty@projects.tartarus.org> "
+ "and pass on the above information.",
+ lineno, y, term->cols, term->rows,
+ term->scrollback, count234(term->scrollback),
+ term->screen, count234(term->screen),
+ term->alt_screen, count234(term->alt_screen), term->alt_sblines,
+ whichtree, treeindex);
+ }
assert(line != NULL);
resizeline(term, line, term->cols);
#define lineptr(x) (lineptr)(term,x,__LINE__,FALSE)
#define scrlineptr(x) (lineptr)(term,x,__LINE__,TRUE)
+static void term_schedule_tblink(Terminal *term);
+static void term_schedule_cblink(Terminal *term);
+
+static void term_timer(void *ctx, long now)
+{
+ Terminal *term = (Terminal *)ctx;
+ int update = FALSE;
+
+ if (term->tblink_pending && now - term->next_tblink >= 0) {
+ term->tblinker = !term->tblinker;
+ term->tblink_pending = FALSE;
+ term_schedule_tblink(term);
+ update = TRUE;
+ }
+
+ if (term->cblink_pending && now - term->next_cblink >= 0) {
+ term->cblinker = !term->cblinker;
+ term->cblink_pending = FALSE;
+ term_schedule_cblink(term);
+ update = TRUE;
+ }
+
+ if (term->in_vbell && now - term->vbell_end >= 0) {
+ term->in_vbell = FALSE;
+ update = TRUE;
+ }
+
+ if (update ||
+ (term->window_update_pending && now - term->next_update >= 0))
+ term_update(term);
+}
+
+static void term_schedule_update(Terminal *term)
+{
+ if (!term->window_update_pending) {
+ term->window_update_pending = TRUE;
+ term->next_update = schedule_timer(UPDATE_DELAY, term_timer, term);
+ }
+}
+
+/*
+ * Call this whenever the terminal window state changes, to queue
+ * an update.
+ */
+static void seen_disp_event(Terminal *term)
+{
+ term->seen_disp_event = TRUE; /* for scrollback-reset-on-activity */
+ term_schedule_update(term);
+}
+
+/*
+ * Call when the terminal's blinking-text settings change, or when
+ * a text blink has just occurred.
+ */
+static void term_schedule_tblink(Terminal *term)
+{
+ if (term->blink_is_real) {
+ if (!term->tblink_pending)
+ term->next_tblink = schedule_timer(TBLINK_DELAY, term_timer, term);
+ term->tblink_pending = TRUE;
+ } else {
+ term->tblinker = 1; /* reset when not in use */
+ term->tblink_pending = FALSE;
+ }
+}
+
+/*
+ * Likewise with cursor blinks.
+ */
+static void term_schedule_cblink(Terminal *term)
+{
+ if (term->cfg.blink_cur && term->has_focus) {
+ if (!term->cblink_pending)
+ term->next_cblink = schedule_timer(CBLINK_DELAY, term_timer, term);
+ term->cblink_pending = TRUE;
+ } else {
+ term->cblinker = 1; /* reset when not in use */
+ term->cblink_pending = FALSE;
+ }
+}
+
+/*
+ * Call to reset cursor blinking on new output.
+ */
+static void term_reset_cblink(Terminal *term)
+{
+ seen_disp_event(term);
+ term->cblinker = 1;
+ term->cblink_pending = FALSE;
+ term_schedule_cblink(term);
+}
+
+/*
+ * Call to begin a visual bell.
+ */
+static void term_schedule_vbell(Terminal *term, int already_started,
+ long startpoint)
+{
+ long ticks_already_gone;
+
+ if (already_started)
+ ticks_already_gone = GETTICKCOUNT() - startpoint;
+ else
+ ticks_already_gone = 0;
+
+ if (ticks_already_gone < VBELL_DELAY) {
+ term->in_vbell = TRUE;
+ term->vbell_end = schedule_timer(VBELL_DELAY - ticks_already_gone,
+ term_timer, term);
+ } else {
+ term->in_vbell = FALSE;
+ }
+}
+
/*
* Set up power-on settings for the terminal.
+ * If 'clear' is false, don't actually clear the primary screen, and
+ * position the cursor below the last non-blank line (scrolling if
+ * necessary).
*/
-static void power_on(Terminal *term)
+static void power_on(Terminal *term, int clear)
{
- term->curs.x = term->curs.y = 0;
term->alt_x = term->alt_y = 0;
term->savecurs.x = term->savecurs.y = 0;
+ term->alt_savecurs.x = term->alt_savecurs.y = 0;
term->alt_t = term->marg_t = 0;
if (term->rows != -1)
term->alt_b = term->marg_b = term->rows - 1;
}
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_wnext = term->wrapnext =
+ term->save_wnext = term->alt_save_wnext = FALSE;
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->alt_cset = term->cset = term->save_cset = term->alt_save_cset = 0;
+ term->alt_utf = term->utf = term->save_utf = term->alt_save_utf = 0;
term->utf_state = 0;
- term->alt_sco_acs = term->sco_acs = term->save_sco_acs = 0;
- term->cset_attr[0] = term->cset_attr[1] = term->save_csattr = CSET_ASCII;
+ term->alt_sco_acs = term->sco_acs =
+ term->save_sco_acs = term->alt_save_sco_acs = 0;
+ term->cset_attr[0] = term->cset_attr[1] =
+ term->save_csattr = term->alt_save_csattr = CSET_ASCII;
term->rvideo = 0;
term->in_vbell = FALSE;
term->cursor_on = 1;
term->big_cursor = 0;
- term->default_attr = term->save_attr = term->curr_attr = ATTR_DEFAULT;
+ term->default_attr = term->save_attr =
+ term->alt_save_attr = term->curr_attr = ATTR_DEFAULT;
term->term_editing = term->term_echoing = FALSE;
term->app_cursor_keys = term->cfg.app_cursor;
term->app_keypad_keys = term->cfg.app_keypad;
swap_screen(term, 1, FALSE, FALSE);
erase_lots(term, FALSE, TRUE, TRUE);
swap_screen(term, 0, FALSE, FALSE);
- erase_lots(term, FALSE, TRUE, TRUE);
+ if (clear)
+ erase_lots(term, FALSE, TRUE, TRUE);
+ term->curs.y = find_last_nonempty_line(term, term->screen) + 1;
+ if (term->curs.y == term->rows) {
+ term->curs.y--;
+ scroll(term, 0, term->rows - 1, 1, TRUE);
+ }
+ } else {
+ term->curs.y = 0;
}
+ term->curs.x = 0;
+ term_schedule_tblink(term);
+ term_schedule_cblink(term);
}
/*
void term_update(Terminal *term)
{
Context ctx;
+
+ term->window_update_pending = FALSE;
+
ctx = get_ctx(term->frontend);
if (ctx) {
int need_sbar_update = term->seen_disp_event;
*/
if (term->cfg.scroll_on_key) {
term->disptop = 0; /* return to main screen */
- term->seen_disp_event = 1;
+ seen_disp_event(term);
}
}
/*
* Same as power_on(), but an external function.
*/
-void term_pwron(Terminal *term)
+void term_pwron(Terminal *term, int clear)
{
- power_on(term);
+ power_on(term, clear);
if (term->ldisc) /* cause ldisc to notice changes */
ldisc_send(term->ldisc, NULL, 0, 0);
term->disptop = 0;
* 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 reset_wrap, reset_decom, reset_bce, reset_tblink, 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_tblink = (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;
+ /*
+ * If the bidi or shaping settings have changed, flush the bidi
+ * cache completely.
+ */
+ if (term->cfg.arabicshaping != cfg->arabicshaping ||
+ term->cfg.bidi != cfg->bidi) {
+ for (i = 0; i < term->bidi_cache_size; i++) {
+ sfree(term->pre_bidi_cache[i].chars);
+ sfree(term->post_bidi_cache[i].chars);
+ term->pre_bidi_cache[i].width = -1;
+ term->pre_bidi_cache[i].chars = NULL;
+ term->post_bidi_cache[i].width = -1;
+ term->post_bidi_cache[i].chars = NULL;
+ }
+ }
+
term->cfg = *cfg; /* STRUCTURE COPY */
if (reset_wrap)
term->use_bce = term->cfg.bce;
set_erase_char(term);
}
- if (reset_blink)
+ if (reset_tblink) {
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.printer) {
term_print_finish(term);
}
+ term_schedule_tblink(term);
+ term_schedule_cblink(term);
}
/*
*/
void term_clrsb(Terminal *term)
{
- termline *line;
+ unsigned char *line;
term->disptop = 0;
while ((line = delpos234(term->scrollback, 0)) != NULL) {
sfree(line); /* this is compressed data, not a termline */
term->logctx = NULL;
term->compatibility_level = TM_PUTTY;
strcpy(term->id_string, "\033[?6c");
- term->last_blink = term->last_tblink = 0;
+ term->cblink_pending = term->tblink_pending = FALSE;
term->paste_buffer = NULL;
term->paste_len = 0;
term->last_paste = 0;
term->seen_disp_event = FALSE;
term->xterm_mouse = term->mouse_is_down = FALSE;
term->reset_132 = FALSE;
- term->blinker = term->tblinker = 0;
+ term->cblinker = term->tblinker = 0;
term->has_focus = 1;
term->repeat_off = FALSE;
term->termstate = TOPLEVEL;
term->tabs = NULL;
deselect(term);
term->rows = term->cols = -1;
- power_on(term);
+ power_on(term, TRUE);
term->beephead = term->beeptail = NULL;
#ifdef OPTIMISE_SCROLL
term->scrollhead = term->scrolltail = NULL;
term->wcTo = NULL;
term->wcFromTo_size = 0;
+ term->window_update_pending = FALSE;
+
term->bidi_cache_size = 0;
term->pre_bidi_cache = term->post_bidi_cache = NULL;
sfree(term->wcTo);
for (i = 0; i < term->bidi_cache_size; i++) {
- sfree(term->pre_bidi_cache[i]);
- sfree(term->post_bidi_cache[i]);
+ sfree(term->pre_bidi_cache[i].chars);
+ sfree(term->post_bidi_cache[i].chars);
}
sfree(term->pre_bidi_cache);
sfree(term->post_bidi_cache);
+ expire_timer_context(term);
+
sfree(term);
}
newsavelines == term->savelines)
return; /* nothing to do */
+ /* Behave sensibly if we're given zero (or negative) rows/cols */
+
+ if (newrows < 1) newrows = 1;
+ if (newcols < 1) newcols = 1;
+
deselect(term);
swap_screen(term, 0, FALSE, FALSE);
for (i = 0; i < newrows; i++) {
newdisp[i] = newline(term, newcols, FALSE);
for (j = 0; j < newcols; j++)
- newdisp[i]->chars[i].attr = ATTR_INVALID;
+ newdisp[i]->chars[j].attr = ATTR_INVALID;
}
if (term->disptext) {
for (i = 0; i < oldrows; i++)
static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos)
{
int t;
+ pos tp;
tree234 *ttr;
if (!which)
t = term->sco_acs;
if (!reset) term->sco_acs = term->alt_sco_acs;
term->alt_sco_acs = t;
+
+ tp = term->savecurs;
+ if (!reset && !keep_cur_pos)
+ term->savecurs = term->alt_savecurs;
+ term->alt_savecurs = tp;
+ t = term->save_cset;
+ if (!reset && !keep_cur_pos)
+ term->save_cset = term->alt_save_cset;
+ term->alt_save_cset = t;
+ t = term->save_csattr;
+ if (!reset && !keep_cur_pos)
+ term->save_csattr = term->alt_save_csattr;
+ term->alt_save_csattr = t;
+ t = term->save_attr;
+ if (!reset && !keep_cur_pos)
+ term->save_attr = term->alt_save_attr;
+ term->alt_save_attr = t;
+ t = term->save_utf;
+ if (!reset && !keep_cur_pos)
+ term->save_utf = term->alt_save_utf;
+ term->alt_save_utf = t;
+ t = term->save_wnext;
+ if (!reset && !keep_cur_pos)
+ term->save_wnext = term->alt_save_wnext;
+ term->alt_save_wnext = t;
+ t = term->save_sco_acs;
+ if (!reset && !keep_cur_pos)
+ term->save_sco_acs = term->alt_save_sco_acs;
+ term->alt_save_sco_acs = t;
}
if (reset && term->screen) {
} else {
while (lines > 0) {
line = delpos234(term->screen, topline);
- cc_check(line); /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+ cc_check(line);
+#endif
if (sb && term->savelines > 0) {
int sblen = count234(term->scrollback);
/*
addpos234(term->scrollback, compressline(line), sblen);
- line = newline(term, term->cols, TRUE);
+ /* now `line' itself can be reused as the bottom line */
/*
* If the user is currently looking at part of the
if (lines > 0) {
for (i = 0; i < nlines; i++)
for (j = 0; j < term->cols; j++)
- copy_termchar(term->disptext[start+i], j,
- term->disptext[start+i+distance]->chars+j);
+ copy_termchar(term->disptext[i], j,
+ term->disptext[i+distance]->chars+j);
if (term->dispcursy >= 0 &&
term->dispcursy >= topline + distance &&
term->dispcursy < topline + distance + nlines)
term->dispcursy -= distance;
for (i = 0; i < distance; i++)
for (j = 0; j < term->cols; j++)
- term->disptext[start+nlines+i]->chars[j].attr |= ATTR_INVALID;
+ term->disptext[nlines+i]->chars[j].attr |= ATTR_INVALID;
} else {
for (i = nlines; i-- ;)
for (j = 0; j < term->cols; j++)
- copy_termchar(term->disptext[start+i+distance], j,
- term->disptext[start+i]->chars+j);
+ copy_termchar(term->disptext[i+distance], j,
+ term->disptext[i]->chars+j);
if (term->dispcursy >= 0 &&
term->dispcursy >= topline &&
term->dispcursy < topline + nlines)
term->dispcursy += distance;
for (i = 0; i < distance; i++)
for (j = 0; j < term->cols; j++)
- term->disptext[start+i]->chars[j].attr |= ATTR_INVALID;
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
}
save_scroll(term, topline, botline, lines);
}
*/
static void toggle_mode(Terminal *term, int mode, int query, int state)
{
- unsigned long ticks;
-
if (query)
switch (mode) {
case 1: /* DECCKM: application cursor keys */
} else {
term->blink_is_real = term->cfg.blinktext;
}
+ term_schedule_tblink(term);
break;
case 3: /* DECCOLM: 80/132 columns */
deselect(term);
* effective visual bell, so that ESC[?5hESC[?5l will
* always be an actually _visible_ visual bell.
*/
- ticks = GETTICKCOUNT();
- /* turn off a previous vbell to avoid inconsistencies */
- if (ticks - term->vbell_startpoint >= VBELL_TIMEOUT)
- term->in_vbell = FALSE;
- if (term->rvideo && !state && /* we're turning it off... */
- (ticks - term->rvbell_startpoint) < VBELL_TIMEOUT) {/*...soon*/
- /* If there's no vbell timeout already, or this one lasts
- * longer, replace vbell_timeout with ours. */
- if (!term->in_vbell ||
- (term->rvbell_startpoint - term->vbell_startpoint <
- VBELL_TIMEOUT))
- term->vbell_startpoint = term->rvbell_startpoint;
- term->in_vbell = TRUE; /* may clear rvideo but set in_vbell */
+ if (term->rvideo && !state) {
+ /* This is an OFF, so set up a vbell */
+ term_schedule_vbell(term, TRUE, term->rvbell_startpoint);
} else if (!term->rvideo && state) {
/* This is an ON, so we notice the time and save it. */
- term->rvbell_startpoint = ticks;
+ term->rvbell_startpoint = GETTICKCOUNT();
}
term->rvideo = state;
- term->seen_disp_event = TRUE;
- if (state)
- term_update(term);
+ seen_disp_event(term);
break;
case 6: /* DECOM: DEC origin mode */
term->dec_om = state;
case 25: /* DECTCEM: enable/disable cursor */
compatibility2(OTHER, VT220);
term->cursor_on = state;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 47: /* alternate screen */
compatibility(OTHER);
case 1048: /* save/restore cursor */
if (!term->cfg.no_alt_screen)
save_cursor(term, state);
- if (!state) term->seen_disp_event = TRUE;
+ if (!state) seen_disp_event(term);
break;
case 1049: /* cursor & alternate screen */
if (state && !term->cfg.no_alt_screen)
save_cursor(term, state);
- if (!state) term->seen_disp_event = TRUE;
+ if (!state) seen_disp_event(term);
compatibility(OTHER);
deselect(term);
swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, FALSE);
* in-memory display. There's a big state machine in here to
* process escape sequences...
*/
-void term_out(Terminal *term)
+static void term_out(Terminal *term)
{
unsigned long c;
int unget;
unget = -1;
chars = NULL; /* placate compiler warnings */
- while (nchars > 0 || bufchain_size(&term->inbuf) > 0) {
+ while (nchars > 0 || unget != -1 || bufchain_size(&term->inbuf) > 0) {
if (unget == -1) {
if (nchars == 0) {
void *ret;
}
}
- /* How about C1 controls ? */
+ /*
+ * How about C1 controls?
+ * Explicitly ignore SCI (0x9a), which we don't translate to DECID.
+ */
if ((c & -32) == 0x80 && term->termstate < DO_CTRLS &&
!term->vt52_mode && has_compat(VT220)) {
- term->termstate = SEEN_ESC;
- term->esc_query = FALSE;
- c = '@' + (c & 0x1F);
+ if (c == 0x9a)
+ c = 0;
+ else {
+ term->termstate = SEEN_ESC;
+ term->esc_query = FALSE;
+ c = '@' + (c & 0x1F);
+ }
}
/* Or the GL control. */
term->wrapnext = FALSE;
/* destructive backspace might be disabled */
if (!term->cfg.no_dbackspace) {
+ check_boundary(term, term->curs.x, term->curs.y);
+ check_boundary(term, term->curs.x+1, term->curs.y);
copy_termchar(scrlineptr(term->curs.y),
term->curs.x, &term->erase_char);
}
if ((c & ~0x1F) == 0 && term->termstate < DO_CTRLS) {
switch (c) {
case '\005': /* ENQ: terminal type query */
- /* Strictly speaking this is VT100 but a VT100 defaults to
+ /*
+ * Strictly speaking this is VT100 but a VT100 defaults to
* no response. Other terminals respond at their option.
*
* Don't put a CR in the default string as this tends to
* upset some weird software.
- *
- * An xterm returns "xterm" (5 characters)
*/
compatibility(ANSIMIN);
if (term->ldisc) {
- char abuf[256], *s, *d;
- int state = 0;
- for (s = term->cfg.answerback, d = abuf; *s; s++) {
- if (state) {
- if (*s >= 'a' && *s <= 'z')
- *d++ = (*s - ('a' - 1));
- else if ((*s >= '@' && *s <= '_') ||
- *s == '?' || (*s & 0x80))
- *d++ = ('@' ^ *s);
- else if (*s == '~')
- *d++ = '^';
- state = 0;
- } else if (*s == '^') {
- state = 1;
- } else
- *d++ = *s;
+ char abuf[lenof(term->cfg.answerback)], *s, *d;
+ for (s = term->cfg.answerback, d = abuf; *s;) {
+ char *n;
+ char c = ctrlparse(s, &n);
+ if (n) {
+ *d++ = c;
+ s = n;
+ } else {
+ *d++ = *s++;
+ }
}
lpage_send(term->ldisc, DEFAULT_CODEPAGE,
abuf, d - abuf, 0);
* Perform an actual beep if we're not overloaded.
*/
if (!term->cfg.bellovl || !term->beep_overloaded) {
- beep(term->frontend, term->cfg.beep);
+ do_beep(term->frontend, term->cfg.beep);
+
if (term->cfg.beep == BELL_VISUAL) {
- term->in_vbell = TRUE;
- term->vbell_startpoint = ticks;
- term_update(term);
+ term_schedule_vbell(term, FALSE, 0);
}
}
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
}
break;
case '\b': /* BS: Back space */
term->wrapnext = FALSE;
else
term->curs.x--;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case '\016': /* LS1: Locking-shift one */
compatibility(VT100);
case '\015': /* CR: Carriage return */
term->curs.x = 0;
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
term->paste_hold = 0;
if (term->logctx)
logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
erase_lots(term, FALSE, FALSE, TRUE);
term->disptop = 0;
term->wrapnext = FALSE;
- term->seen_disp_event = 1;
+ seen_disp_event(term);
break;
}
case '\013': /* VT: Line tabulation */
if (term->cfg.lfhascr)
term->curs.x = 0;
term->wrapnext = FALSE;
- term->seen_disp_event = 1;
+ seen_disp_event(term);
term->paste_hold = 0;
if (term->logctx)
logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
check_selection(term, old_curs, term->curs);
}
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
}
} else
if (DIRECT_CHAR(c))
width = 1;
if (!width)
- width = wcwidth((wchar_t) c);
+ width = (term->cfg.cjk_ambig_wide ?
+ mk_wcwidth_cjk((wchar_t) c) :
+ mk_wcwidth((wchar_t) c));
if (term->wrapnext && term->wrap && width > 0) {
cline->lattr |= LATTR_WRAPPED;
else if (term->curs.y < term->rows - 1)
term->curs.y++;
term->curs.x = 0;
+ cline = scrlineptr(term->curs.y);
/* 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);
}
add_cc(cline, x, c);
- term->seen_disp_event = 1;
+ seen_disp_event(term);
}
continue;
default:
term->wrapnext = FALSE;
}
}
- term->seen_disp_event = 1;
+ seen_disp_event(term);
}
break;
case '8': /* DECRC: restore cursor */
compatibility(VT100);
save_cursor(term, FALSE);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case '=': /* DECKPAM: Keypad application mode */
compatibility(VT100);
else if (term->curs.y < term->rows - 1)
term->curs.y++;
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'E': /* NEL: exactly equivalent to CR-LF */
compatibility(VT100);
else if (term->curs.y < term->rows - 1)
term->curs.y++;
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'M': /* RI: reverse index - backwards LF */
compatibility(VT100);
else if (term->curs.y > 0)
term->curs.y--;
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'Z': /* DECID: terminal type query */
compatibility(VT100);
break;
case 'c': /* RIS: restore power-on settings */
compatibility(VT100);
- power_on(term);
+ power_on(term, TRUE);
if (term->ldisc) /* cause ldisc to notice changes */
ldisc_send(term->ldisc, NULL, 0, 0);
if (term->reset_132) {
term->reset_132 = 0;
}
term->disptop = 0;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'H': /* HTS: set a tab */
compatibility(VT100);
ldata->lattr = LATTR_NORM;
}
term->disptop = 0;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
scrtop.x = scrtop.y = 0;
scrbot.x = 0;
scrbot.y = term->rows;
case 'A': /* CUU: move up N lines */
move(term, term->curs.x,
term->curs.y - def(term->esc_args[0], 1), 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'e': /* VPR: move down N lines */
compatibility(ANSI);
case 'B': /* CUD: Cursor down */
move(term, term->curs.x,
term->curs.y + def(term->esc_args[0], 1), 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case ANSI('c', '>'): /* DA: report xterm version */
compatibility(OTHER);
case 'C': /* CUF: Cursor right */
move(term, term->curs.x + def(term->esc_args[0], 1),
term->curs.y, 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'D': /* CUB: move left N cols */
move(term, term->curs.x - def(term->esc_args[0], 1),
term->curs.y, 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'E': /* CNL: move down N lines and CR */
compatibility(ANSI);
move(term, 0,
term->curs.y + def(term->esc_args[0], 1), 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'F': /* CPL: move up N lines and CR */
compatibility(ANSI);
move(term, 0,
term->curs.y - def(term->esc_args[0], 1), 1);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'G': /* CHA */
case '`': /* HPA: set horizontal posn */
compatibility(ANSI);
move(term, def(term->esc_args[0], 1) - 1,
term->curs.y, 0);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'd': /* VPA: set vertical posn */
compatibility(ANSI);
((term->dec_om ? term->marg_t : 0) +
def(term->esc_args[0], 1) - 1),
(term->dec_om ? 2 : 0));
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'H': /* CUP */
case 'f': /* HVP: set horz and vert posns at once */
((term->dec_om ? term->marg_t : 0) +
def(term->esc_args[0], 1) - 1),
(term->dec_om ? 2 : 0));
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'J': /* ED: erase screen or parts of it */
{
- unsigned int i = def(term->esc_args[0], 0) + 1;
- if (i > 3)
- i = 0;
- erase_lots(term, FALSE, !!(i & 2), !!(i & 1));
+ unsigned int i = def(term->esc_args[0], 0);
+ if (i == 3) {
+ /* Erase Saved Lines (xterm)
+ * This follows Thomas Dickey's xterm. */
+ term_clrsb(term);
+ } else {
+ i++;
+ if (i > 3)
+ i = 0;
+ erase_lots(term, FALSE, !!(i & 2), !!(i & 1));
+ }
}
term->disptop = 0;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'K': /* EL: erase line or parts of it */
{
i = 0;
erase_lots(term, TRUE, !!(i & 2), !!(i & 1));
}
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'L': /* IL: insert lines */
compatibility(VT102);
if (term->curs.y <= term->marg_b)
scroll(term, term->curs.y, term->marg_b,
-def(term->esc_args[0], 1), FALSE);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'M': /* DL: delete lines */
compatibility(VT102);
scroll(term, term->curs.y, term->marg_b,
def(term->esc_args[0], 1),
TRUE);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case '@': /* ICH: insert chars */
/* XXX VTTEST says this is vt220, vt510 manual says vt102 */
compatibility(VT102);
insch(term, def(term->esc_args[0], 1));
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'P': /* DCH: delete chars */
compatibility(VT102);
insch(term, -def(term->esc_args[0], 1));
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'c': /* DA: terminal type query */
compatibility(VT100);
*/
term->curs.y = (term->dec_om ?
term->marg_t : 0);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
}
}
break;
compatibility(SCOANSI);
term->blink_is_real = FALSE;
term->curr_attr |= ATTR_BLINK;
+ term_schedule_tblink(term);
break;
case 7: /* enable reverse video */
term->curr_attr |= ATTR_REVERSE;
case 95:
case 96:
case 97:
- /* xterm-style bright foreground */
+ /* aixterm-style bright foreground */
term->curr_attr &= ~ATTR_FGMASK;
term->curr_attr |=
- ((term->esc_args[i] - 90 + 16)
+ ((term->esc_args[i] - 90 + 8)
<< ATTR_FGSHIFT);
break;
case 39: /* default-foreground */
case 105:
case 106:
case 107:
- /* xterm-style bright background */
+ /* aixterm-style bright background */
term->curr_attr &= ~ATTR_BGMASK;
term->curr_attr |=
- ((term->esc_args[i] - 100 + 16)
+ ((term->esc_args[i] - 100 + 8)
<< ATTR_BGSHIFT);
break;
case 49: /* default-background */
term->curr_attr &= ~ATTR_BGMASK;
term->curr_attr |= ATTR_DEFBG;
break;
+ case 38: /* xterm 256-colour mode */
+ if (i+2 < term->esc_nargs &&
+ term->esc_args[i+1] == 5) {
+ term->curr_attr &= ~ATTR_FGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i+2] & 0xFF)
+ << ATTR_FGSHIFT);
+ i += 2;
+ }
+ break;
+ case 48: /* xterm 256-colour mode */
+ if (i+2 < term->esc_nargs &&
+ term->esc_args[i+1] == 5) {
+ term->curr_attr &= ~ATTR_BGMASK;
+ term->curr_attr |=
+ ((term->esc_args[i+2] & 0xFF)
+ << ATTR_BGSHIFT);
+ i += 2;
+ }
+ break;
}
}
set_erase_char(term);
break;
case 'u': /* restore cursor */
save_cursor(term, FALSE);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 't': /* DECSLPP: set page size - ie window height */
/*
break;
case 20:
if (term->ldisc &&
- !term->cfg.no_remote_qtitle) {
- p = get_window_title(term->frontend, TRUE);
+ term->cfg.remote_qtitle_action != TITLE_NONE) {
+ if(term->cfg.remote_qtitle_action == TITLE_REAL)
+ p = get_window_title(term->frontend, TRUE);
+ else
+ p = EMPTY_WINDOW_TITLE;
len = strlen(p);
ldisc_send(term->ldisc, "\033]L", 3, 0);
ldisc_send(term->ldisc, p, len, 0);
break;
case 21:
if (term->ldisc &&
- !term->cfg.no_remote_qtitle) {
- p = get_window_title(term->frontend,FALSE);
+ term->cfg.remote_qtitle_action != TITLE_NONE) {
+ if(term->cfg.remote_qtitle_action == TITLE_REAL)
+ p = get_window_title(term->frontend, FALSE);
+ else
+ p = EMPTY_WINDOW_TITLE;
len = strlen(p);
ldisc_send(term->ldisc, "\033]l", 3, 0);
ldisc_send(term->ldisc, p, len, 0);
scroll(term, term->marg_t, term->marg_b,
def(term->esc_args[0], 1), TRUE);
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case 'T': /* SD: Scroll down */
compatibility(SCOANSI);
scroll(term, term->marg_t, term->marg_b,
-def(term->esc_args[0], 1), TRUE);
term->wrapnext = FALSE;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
break;
case ANSI('|', '*'): /* DECSNLS */
/*
while (n--)
copy_termchar(cline, p++,
&term->erase_char);
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
}
break;
case 'x': /* DECREQTPARM: report terminal characteristics */
}
}
break;
- case 'Z': /* CBT: BackTab for xterm */
+ case 'Z': /* CBT */
compatibility(OTHER);
{
int i = def(term->esc_args[0], 1);
case ANSI('D', '='):
compatibility(SCOANSI);
term->blink_is_real = FALSE;
+ term_schedule_tblink(term);
if (term->esc_args[0]>=1)
term->curr_attr |= ATTR_BLINK;
else
case ANSI('E', '='):
compatibility(SCOANSI);
term->blink_is_real = (term->esc_args[0] >= 1);
+ term_schedule_tblink(term);
break;
case ANSI('F', '='): /* set normal foreground */
compatibility(SCOANSI);
if (term->esc_args[0] >= 0 && term->esc_args[0] < 16) {
long colour =
(sco2ansicolour[term->esc_args[0] & 0x7] |
- ((term->esc_args[0] & 0x8) << 1)) <<
+ (term->esc_args[0] & 0x8)) <<
ATTR_FGSHIFT;
term->curr_attr &= ~ATTR_FGMASK;
term->curr_attr |= colour;
term->default_attr &= ~ATTR_FGMASK;
term->default_attr |= colour;
+ set_erase_char(term);
}
break;
case ANSI('G', '='): /* set normal background */
if (term->esc_args[0] >= 0 && term->esc_args[0] < 16) {
long colour =
(sco2ansicolour[term->esc_args[0] & 0x7] |
- ((term->esc_args[0] & 0x8) << 1)) <<
+ (term->esc_args[0] & 0x8)) <<
ATTR_BGSHIFT;
term->curr_attr &= ~ATTR_BGMASK;
term->curr_attr |= colour;
term->default_attr &= ~ATTR_BGMASK;
term->default_attr |= colour;
+ set_erase_char(term);
}
break;
case ANSI('L', '='):
break;
case SEEN_OSC_P:
{
- int max = (term->osc_strlen == 0 ? 21 : 16);
+ int max = (term->osc_strlen == 0 ? 21 : 15);
int val;
if ((int)c >= '0' && (int)c <= '9')
val = c - '0';
break;
case VT52_ESC:
term->termstate = TOPLEVEL;
- term->seen_disp_event = TRUE;
+ seen_disp_event(term);
switch (c) {
case 'A':
move(term, term->curs.x, term->curs.y - 1, 1);
*/
term->vt52_mode = FALSE;
term->blink_is_real = term->cfg.blinktext;
+ term_schedule_tblink(term);
break;
#if 0
case '^':
term->termstate = TOPLEVEL;
term->curr_attr &= ~ATTR_FGMASK;
term->curr_attr &= ~ATTR_BOLD;
- term->curr_attr |= (c & 0x7) << ATTR_FGSHIFT;
- if ((c & 0x8) || term->vt52_bold)
- term->curr_attr |= ATTR_BOLD;
-
+ term->curr_attr |= (c & 0xF) << ATTR_FGSHIFT;
set_erase_char(term);
break;
case VT52_BG:
term->termstate = TOPLEVEL;
term->curr_attr &= ~ATTR_BGMASK;
term->curr_attr &= ~ATTR_BLINK;
- term->curr_attr |= (c & 0x7) << ATTR_BGSHIFT;
-
- /* Note: bold background */
- if (c & 0x8)
- term->curr_attr |= ATTR_BLINK;
-
+ term->curr_attr |= (c & 0xF) << ATTR_BGSHIFT;
set_erase_char(term);
break;
#endif
}
term_print_flush(term);
- logflush(term->logctx);
+ if (term->cfg.logflush)
+ logflush(term->logctx);
}
/*
if (line >= term->bidi_cache_size)
return FALSE; /* cache doesn't have this many lines */
- if (!term->pre_bidi_cache[line])
+ if (!term->pre_bidi_cache[line].chars)
return FALSE; /* cache doesn't contain _this_ line */
+ if (term->pre_bidi_cache[line].width != width)
+ return FALSE; /* line is wrong width */
+
for (i = 0; i < width; i++)
- if (!termchars_equal(term->pre_bidi_cache[line] + i, lbefore + i))
+ if (!termchars_equal(term->pre_bidi_cache[line].chars+i, lbefore+i))
return FALSE; /* line doesn't match cache */
return TRUE; /* it didn't match. */
}
static void term_bidi_cache_store(Terminal *term, int line, termchar *lbefore,
- termchar *lafter, int width)
+ termchar *lafter, bidi_char *wcTo,
+ int width, int size)
{
+ int i;
+
if (!term->pre_bidi_cache || term->bidi_cache_size <= line) {
int j = term->bidi_cache_size;
term->bidi_cache_size = line+1;
term->pre_bidi_cache = sresize(term->pre_bidi_cache,
term->bidi_cache_size,
- termchar *);
+ struct bidi_cache_entry);
term->post_bidi_cache = sresize(term->post_bidi_cache,
term->bidi_cache_size,
- termchar *);
+ struct bidi_cache_entry);
while (j < term->bidi_cache_size) {
- term->pre_bidi_cache[j] = term->post_bidi_cache[j] = NULL;
+ term->pre_bidi_cache[j].chars =
+ term->post_bidi_cache[j].chars = NULL;
+ term->pre_bidi_cache[j].width =
+ term->post_bidi_cache[j].width = -1;
+ term->pre_bidi_cache[j].forward =
+ term->post_bidi_cache[j].forward = NULL;
+ term->pre_bidi_cache[j].backward =
+ term->post_bidi_cache[j].backward = NULL;
j++;
}
}
- sfree(term->pre_bidi_cache[line]);
- sfree(term->post_bidi_cache[line]);
+ sfree(term->pre_bidi_cache[line].chars);
+ sfree(term->post_bidi_cache[line].chars);
+ sfree(term->post_bidi_cache[line].forward);
+ sfree(term->post_bidi_cache[line].backward);
+
+ term->pre_bidi_cache[line].width = width;
+ term->pre_bidi_cache[line].chars = snewn(size, termchar);
+ term->post_bidi_cache[line].width = width;
+ term->post_bidi_cache[line].chars = snewn(size, termchar);
+ term->post_bidi_cache[line].forward = snewn(width, int);
+ term->post_bidi_cache[line].backward = snewn(width, int);
+
+ memcpy(term->pre_bidi_cache[line].chars, lbefore, size * TSIZE);
+ memcpy(term->post_bidi_cache[line].chars, lafter, size * TSIZE);
+ memset(term->post_bidi_cache[line].forward, 0, width * sizeof(int));
+ memset(term->post_bidi_cache[line].backward, 0, width * sizeof(int));
+
+ for (i = 0; i < width; i++) {
+ int p = wcTo[i].index;
+
+ assert(0 <= p && p < width);
+
+ term->post_bidi_cache[line].backward[i] = p;
+ term->post_bidi_cache[line].forward[p] = i;
+ }
+}
+
+/*
+ * Prepare the bidi information for a screen line. Returns the
+ * transformed list of termchars, or NULL if no transformation at
+ * all took place (because bidi is disabled). If return was
+ * non-NULL, auxiliary information such as the forward and reverse
+ * mappings of permutation position are available in
+ * term->post_bidi_cache[scr_y].*.
+ */
+static termchar *term_bidi_line(Terminal *term, struct termline *ldata,
+ int scr_y)
+{
+ termchar *lchars;
+ int it;
+
+ /* Do Arabic shaping and bidi. */
+ if(!term->cfg.bidi || !term->cfg.arabicshaping) {
+
+ if (!term_bidi_cache_hit(term, scr_y, ldata->chars, term->cols)) {
+
+ if (term->wcFromTo_size < term->cols) {
+ term->wcFromTo_size = term->cols;
+ term->wcFrom = sresize(term->wcFrom, term->wcFromTo_size,
+ bidi_char);
+ term->wcTo = sresize(term->wcTo, term->wcFromTo_size,
+ bidi_char);
+ }
+
+ for(it=0; it<term->cols ; it++)
+ {
+ unsigned long uc = (ldata->chars[it].chr);
+
+ switch (uc & CSET_MASK) {
+ case CSET_LINEDRW:
+ if (!term->cfg.rawcnp) {
+ uc = term->ucsdata->unitab_xterm[uc & 0xFF];
+ break;
+ }
+ case CSET_ASCII:
+ uc = term->ucsdata->unitab_line[uc & 0xFF];
+ break;
+ case CSET_SCOACS:
+ uc = term->ucsdata->unitab_scoacs[uc&0xFF];
+ break;
+ }
+ switch (uc & CSET_MASK) {
+ case CSET_ACP:
+ uc = term->ucsdata->unitab_font[uc & 0xFF];
+ break;
+ case CSET_OEMCP:
+ uc = term->ucsdata->unitab_oemcp[uc & 0xFF];
+ break;
+ }
+
+ term->wcFrom[it].origwc = term->wcFrom[it].wc =
+ (wchar_t)uc;
+ term->wcFrom[it].index = it;
+ }
+
+ if(!term->cfg.bidi)
+ do_bidi(term->wcFrom, term->cols);
+
+ /* this is saved iff done from inside the shaping */
+ if(!term->cfg.bidi && term->cfg.arabicshaping)
+ for(it=0; it<term->cols; it++)
+ term->wcTo[it] = term->wcFrom[it];
+
+ if(!term->cfg.arabicshaping)
+ do_shape(term->wcFrom, term->wcTo, term->cols);
- term->pre_bidi_cache[line] = snewn(width, termchar);
- term->post_bidi_cache[line] = snewn(width, termchar);
+ if (term->ltemp_size < ldata->size) {
+ term->ltemp_size = ldata->size;
+ term->ltemp = sresize(term->ltemp, term->ltemp_size,
+ termchar);
+ }
+
+ memcpy(term->ltemp, ldata->chars, ldata->size * TSIZE);
+
+ for(it=0; it<term->cols ; it++)
+ {
+ term->ltemp[it] = ldata->chars[term->wcTo[it].index];
+ if (term->ltemp[it].cc_next)
+ term->ltemp[it].cc_next -=
+ it - term->wcTo[it].index;
+
+ if (term->wcTo[it].origwc != term->wcTo[it].wc)
+ term->ltemp[it].chr = term->wcTo[it].wc;
+ }
+ term_bidi_cache_store(term, scr_y, ldata->chars,
+ term->ltemp, term->wcTo,
+ term->cols, ldata->size);
- memcpy(term->pre_bidi_cache[line], lbefore, width * TSIZE);
- memcpy(term->post_bidi_cache[line], lafter, width * TSIZE);
+ lchars = term->ltemp;
+ } else {
+ lchars = term->post_bidi_cache[scr_y].chars;
+ }
+ } else {
+ lchars = NULL;
+ }
+
+ return lchars;
}
/*
*/
static void do_paint(Terminal *term, Context ctx, int may_optimise)
{
- int i, it, j, our_curs_y, our_curs_x;
+ int i, j, our_curs_y, our_curs_x;
int rv, cursor;
pos scrpos;
wchar_t *ch;
int chlen;
- termchar cursor_background;
- unsigned long ticks;
#ifdef OPTIMISE_SCROLL
struct scrollregion *sr;
#endif /* OPTIMISE_SCROLL */
-
- cursor_background = term->basic_erase_char;
+ termchar *newline;
chlen = 1024;
ch = snewn(chlen, wchar_t);
- /*
- * Check the visual bell state.
- */
- if (term->in_vbell) {
- ticks = GETTICKCOUNT();
- if (ticks - term->vbell_startpoint >= VBELL_TIMEOUT)
- term->in_vbell = FALSE;
- }
+ newline = snewn(term->cols, termchar);
rv = (!term->rvideo ^ !term->in_vbell ? ATTR_REVERSE : 0);
* screen array, disptop, scrtop,
* selection, rv,
* cfg.blinkpc, blink_is_real, tblinker,
- * curs.y, curs.x, blinker, cfg.blink_cur, cursor_on, has_focus, wrapnext
+ * curs.y, curs.x, cblinker, cfg.blink_cur, cursor_on, has_focus, wrapnext
*/
/* Has the cursor position or type changed ? */
if (term->cursor_on) {
if (term->has_focus) {
- if (term->blinker || !term->cfg.blink_cur)
+ if (term->cblinker || !term->cfg.blink_cur)
cursor = TATTR_ACTCURS;
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.
+ * Adjust the cursor position:
+ * - for bidi
+ * - 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.
*/
termline *ldata = lineptr(term->curs.y);
+ termchar *lchars;
+
our_curs_x = term->curs.x;
+
+ if ( (lchars = term_bidi_line(term, ldata, our_curs_y)) != NULL) {
+ our_curs_x = term->post_bidi_cache[our_curs_y].forward[our_curs_x];
+ } else
+ lchars = ldata->chars;
+
if (our_curs_x > 0 &&
- ldata->chars[our_curs_x].chr == UCSWIDE)
+ lchars[our_curs_x].chr == UCSWIDE)
our_curs_x--;
+
unlineptr(ldata);
}
int start = 0;
int ccount = 0;
int last_run_dirty = 0;
+ int laststart, dirtyrect;
+ int *backward;
scrpos.y = i + term->disptop;
ldata = lineptr(scrpos.y);
- dirty_run = dirty_line = (ldata->lattr !=
- term->disptext[i]->lattr);
- term->disptext[i]->lattr = ldata->lattr;
-
/* Do Arabic shaping and bidi. */
- if(!term->cfg.bidi || !term->cfg.arabicshaping) {
-
- if (!term_bidi_cache_hit(term, i, ldata->chars, term->cols)) {
-
- if (term->wcFromTo_size < term->cols) {
- term->wcFromTo_size = term->cols;
- term->wcFrom = sresize(term->wcFrom, term->wcFromTo_size,
- bidi_char);
- term->wcTo = sresize(term->wcTo, term->wcFromTo_size,
- bidi_char);
- }
-
- for(it=0; it<term->cols ; it++)
- {
- unsigned long uc = (ldata->chars[it].chr);
-
- switch (uc & CSET_MASK) {
- case CSET_LINEDRW:
- if (!term->cfg.rawcnp) {
- uc = term->ucsdata->unitab_xterm[uc & 0xFF];
- break;
- }
- case CSET_ASCII:
- uc = term->ucsdata->unitab_line[uc & 0xFF];
- break;
- case CSET_SCOACS:
- uc = term->ucsdata->unitab_scoacs[uc&0xFF];
- break;
- }
- switch (uc & CSET_MASK) {
- case CSET_ACP:
- uc = term->ucsdata->unitab_font[uc & 0xFF];
- break;
- case CSET_OEMCP:
- uc = term->ucsdata->unitab_oemcp[uc & 0xFF];
- break;
- }
-
- term->wcFrom[it].origwc = term->wcFrom[it].wc =
- (wchar_t)uc;
- term->wcFrom[it].index = it;
- }
-
- if(!term->cfg.bidi)
- do_bidi(term->wcFrom, term->cols);
-
- /* this is saved iff done from inside the shaping */
- if(!term->cfg.bidi && term->cfg.arabicshaping)
- for(it=0; it<term->cols; it++)
- term->wcTo[it] = term->wcFrom[it];
-
- if(!term->cfg.arabicshaping)
- do_shape(term->wcFrom, term->wcTo, term->cols);
-
- if (term->ltemp_size < ldata->size) {
- term->ltemp_size = ldata->size;
- term->ltemp = sresize(term->ltemp, term->ltemp_size,
- termchar);
- }
-
- memcpy(term->ltemp, ldata->chars, ldata->size * TSIZE);
-
- for(it=0; it<term->cols ; it++)
- {
- term->ltemp[it] = ldata->chars[term->wcTo[it].index];
- if (term->ltemp[it].cc_next)
- term->ltemp[it].cc_next -=
- it - term->wcTo[it].index;
-
- if (term->wcTo[it].origwc != term->wcTo[it].wc)
- term->ltemp[it].chr = term->wcTo[it].wc;
- }
- term_bidi_cache_store(term, i, ldata->chars,
- term->ltemp, ldata->size);
-
- lchars = term->ltemp;
- } else {
- lchars = term->post_bidi_cache[i];
- }
- } else
+ lchars = term_bidi_line(term, ldata, i);
+ if (lchars) {
+ backward = term->post_bidi_cache[i].backward;
+ } else {
lchars = ldata->chars;
+ backward = NULL;
+ }
+ /*
+ * First loop: work along the line deciding what we want
+ * each character cell to look like.
+ */
for (j = 0; j < term->cols; j++) {
unsigned long tattr, tchar;
termchar *d = lchars + j;
- int break_run, do_copy;
- scrpos.x = j;
+ scrpos.x = backward ? backward[j] : j;
tchar = d->chr;
tattr = d->attr;
+ if (!term->cfg.ansi_colour)
+ tattr = (tattr & ~(ATTR_FGMASK | ATTR_BGMASK)) |
+ ATTR_DEFFG | ATTR_DEFBG;
+
+ if (!term->cfg.xterm_256_colour) {
+ int colour;
+ colour = (tattr & ATTR_FGMASK) >> ATTR_FGSHIFT;
+ if (colour >= 16 && colour < 256)
+ tattr = (tattr &~ ATTR_FGMASK) | ATTR_DEFFG;
+ colour = (tattr & ATTR_BGMASK) >> ATTR_BGSHIFT;
+ if (colour >= 16 && colour < 256)
+ tattr = (tattr &~ ATTR_BGMASK) | ATTR_DEFBG;
+ }
+
switch (tchar & CSET_MASK) {
case CSET_ASCII:
tchar = term->ucsdata->unitab_line[tchar & 0xFF];
*/
if (tchar != term->disptext[i]->chars[j].chr ||
tattr != (term->disptext[i]->chars[j].attr &~
- ATTR_NARROW)) {
+ (ATTR_NARROW | DATTR_MASK))) {
if ((tattr & ATTR_WIDE) == 0 && char_width(ctx, tchar) == 2)
tattr |= ATTR_NARROW;
} else if (term->disptext[i]->chars[j].attr & ATTR_NARROW)
tattr |= ATTR_NARROW;
- /* Cursor here ? Save the 'background' */
if (i == our_curs_y && j == our_curs_x) {
- /* FULL-TERMCHAR */
- cursor_background.chr = tchar;
- cursor_background.attr = tattr;
- /* For once, this cc_next field is an absolute index in lchars */
- if (d->cc_next)
- cursor_background.cc_next = d->cc_next + j;
- else
- cursor_background.cc_next = 0;
+ tattr |= cursor;
+ term->curstype = cursor;
term->dispcursx = j;
term->dispcursy = i;
}
+ /* FULL-TERMCHAR */
+ newline[j].attr = tattr;
+ newline[j].chr = tchar;
+ /* Combining characters are still read from lchars */
+ newline[j].cc_next = 0;
+ }
+
+ /*
+ * Now loop over the line again, noting where things have
+ * changed.
+ *
+ * During this loop, we keep track of where we last saw
+ * DATTR_STARTRUN. Any mismatch automatically invalidates
+ * _all_ of the containing run that was last printed: that
+ * is, any rectangle that was drawn in one go in the
+ * previous update should be either left completely alone
+ * or overwritten in its entirety. This, along with the
+ * expectation that front ends clip all text runs to their
+ * bounding rectangle, should solve any possible problems
+ * with fonts that overflow their character cells.
+ */
+ laststart = 0;
+ dirtyrect = FALSE;
+ for (j = 0; j < term->cols; j++) {
+ if (term->disptext[i]->chars[j].attr & DATTR_STARTRUN) {
+ laststart = j;
+ dirtyrect = FALSE;
+ }
+
+ if (term->disptext[i]->chars[j].chr != newline[j].chr ||
+ (term->disptext[i]->chars[j].attr &~ DATTR_MASK)
+ != newline[j].attr) {
+ int k;
+
+ if (!dirtyrect) {
+ for (k = laststart; k < j; k++)
+ term->disptext[i]->chars[k].attr |= ATTR_INVALID;
+
+ dirtyrect = TRUE;
+ }
+ }
+
+ if (dirtyrect)
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+ }
+
+ /*
+ * Finally, loop once more and actually do the drawing.
+ */
+ dirty_run = dirty_line = (ldata->lattr !=
+ term->disptext[i]->lattr);
+ term->disptext[i]->lattr = ldata->lattr;
+
+ for (j = 0; j < term->cols; j++) {
+ unsigned long tattr, tchar;
+ int break_run, do_copy;
+ termchar *d = lchars + j;
+
+ tattr = newline[j].attr;
+ tchar = newline[j].chr;
+
if ((term->disptext[i]->chars[j].attr ^ tattr) & ATTR_WIDE)
dirty_line = TRUE;
if (!term->ucsdata->dbcs_screenfont && !dirty_line) {
if (term->disptext[i]->chars[j].chr == tchar &&
- term->disptext[i]->chars[j].attr == tattr)
+ (term->disptext[i]->chars[j].attr &~ DATTR_MASK) == tattr)
break_run = TRUE;
else if (!dirty_run && ccount == 1)
break_run = TRUE;
if (break_run) {
if ((dirty_run || last_run_dirty) && ccount > 0) {
- do_text(ctx, start, i, ch, ccount, attr, ldata->lattr);
+ do_text(ctx, start, i, ch, ccount, attr,
+ ldata->lattr);
+ if (attr & (TATTR_ACTCURS | TATTR_PASCURS))
+ do_cursor(ctx, start, i, ch, ccount, attr,
+ ldata->lattr);
+
updated_line = 1;
}
start = j;
copy_termchar(term->disptext[i], j, d);
term->disptext[i]->chars[j].chr = tchar;
term->disptext[i]->chars[j].attr = tattr;
+ if (start == j)
+ term->disptext[i]->chars[j].attr |= DATTR_STARTRUN;
}
/* If it's a wide char step along to the next one. */
}
}
if (dirty_run && ccount > 0) {
- do_text(ctx, start, i, ch, ccount, attr, ldata->lattr);
- updated_line = 1;
- }
-
- /* Cursor on this line ? (and changed) */
- if (i == our_curs_y && (term->curstype != cursor || updated_line)) {
- ch[0] = (wchar_t) cursor_background.chr;
- attr = cursor_background.attr | cursor;
- ccount = 1;
-
- if (cursor_background.cc_next) {
- termchar *dd = ldata->chars + cursor_background.cc_next;
+ do_text(ctx, start, i, ch, ccount, attr,
+ ldata->lattr);
+ if (attr & (TATTR_ACTCURS | TATTR_PASCURS))
+ do_cursor(ctx, start, i, ch, ccount, attr,
+ ldata->lattr);
- while (1) {
- unsigned long schar;
-
- schar = dd->chr;
- switch (schar & CSET_MASK) {
- case CSET_ASCII:
- schar = term->ucsdata->unitab_line[schar & 0xFF];
- break;
- case CSET_LINEDRW:
- schar = term->ucsdata->unitab_xterm[schar & 0xFF];
- break;
- case CSET_SCOACS:
- schar = term->ucsdata->unitab_scoacs[schar&0xFF];
- break;
- }
-
- if (ccount >= chlen) {
- chlen = ccount + 256;
- ch = sresize(ch, chlen, wchar_t);
- }
- ch[ccount++] = (wchar_t) schar;
-
- if (dd->cc_next)
- dd += dd->cc_next;
- else
- break;
- }
-
- attr |= TATTR_COMBINING;
- }
-
- do_cursor(ctx, our_curs_x, i, ch, ccount, attr, ldata->lattr);
- term->curstype = cursor;
+ updated_line = 1;
}
unlineptr(ldata);
}
+ sfree(newline);
sfree(ch);
}
/*
- * Flick the switch that says if blinking things should be shown or hidden.
- */
-
-void term_blink(Terminal *term, int flg)
-{
- long now, blink_diff;
-
- now = GETTICKCOUNT();
- blink_diff = now - term->last_tblink;
-
- /* Make sure the text blinks no more than 2Hz; we'll use 0.45 s period. */
- if (blink_diff < 0 || blink_diff > (TICKSPERSEC * 9 / 20)) {
- term->last_tblink = now;
- term->tblinker = !term->tblinker;
- }
-
- if (flg) {
- term->blinker = 1;
- term->last_blink = now;
- return;
- }
-
- blink_diff = now - term->last_blink;
-
- /* Make sure the cursor blinks no faster than system blink rate */
- if (blink_diff >= 0 && blink_diff < (long) CURSORBLINK)
- return;
-
- term->last_blink = now;
- term->blinker = !term->blinker;
-}
-
-/*
* Invalidate the whole screen so it will be repainted in full.
*/
void term_invalidate(Terminal *term)
for (i = 0; i < term->rows; i++)
for (j = 0; j < term->cols; j++)
- term->disptext[i]->chars[j].attr = ATTR_INVALID;
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
+
+ term_schedule_update(term);
}
/*
for (i = top; i <= bottom && i < term->rows; i++) {
if ((term->disptext[i]->lattr & LATTR_MODE) == LATTR_NORM)
for (j = left; j <= right && j < term->cols; j++)
- term->disptext[i]->chars[j].attr = ATTR_INVALID;
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
else
for (j = left / 2; j <= right / 2 + 1 && j < term->cols; j++)
- term->disptext[i]->chars[j].attr = ATTR_INVALID;
+ term->disptext[i]->chars[j].attr |= ATTR_INVALID;
}
- /* This should happen soon enough, also for some reason it sometimes
- * fails to actually do anything when re-sizing ... painting the wrong
- * window perhaps ?
- */
- if (immediately)
+ if (immediately) {
do_paint (term, ctx, FALSE);
+ } else {
+ term_schedule_update(term);
+ }
}
/*
term_update(term);
}
+/*
+ * Helper routine for clipme(): growing buffer.
+ */
+typedef struct {
+ int buflen; /* amount of allocated space in textbuf/attrbuf */
+ int bufpos; /* amount of actual data */
+ wchar_t *textbuf; /* buffer for copied text */
+ wchar_t *textptr; /* = textbuf + bufpos (current insertion point) */
+ int *attrbuf; /* buffer for copied attributes */
+ int *attrptr; /* = attrbuf + bufpos */
+} clip_workbuf;
+
+static void clip_addchar(clip_workbuf *b, wchar_t chr, int attr)
+{
+ if (b->bufpos >= b->buflen) {
+ b->buflen += 128;
+ b->textbuf = sresize(b->textbuf, b->buflen, wchar_t);
+ b->textptr = b->textbuf + b->bufpos;
+ b->attrbuf = sresize(b->attrbuf, b->buflen, int);
+ b->attrptr = b->attrbuf + b->bufpos;
+ }
+ *b->textptr++ = chr;
+ *b->attrptr++ = attr;
+ b->bufpos++;
+}
+
static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
{
- wchar_t *workbuf;
- wchar_t *wbptr; /* where next char goes within workbuf */
+ clip_workbuf buf;
int old_top_x;
- int wblen = 0; /* workbuf len */
- int buflen; /* amount of memory allocated to workbuf */
+ int attr;
+
+ buf.buflen = 5120;
+ buf.bufpos = 0;
+ buf.textptr = buf.textbuf = snewn(buf.buflen, wchar_t);
+ buf.attrptr = buf.attrbuf = snewn(buf.buflen, int);
- buflen = 5120; /* Default size */
- workbuf = snewn(buflen, wchar_t);
- wbptr = workbuf; /* start filling here */
old_top_x = top.x; /* needed for rect==1 */
while (poslt(top, bottom)) {
* newline at the end)...
*/
if (!(ldata->lattr & LATTR_WRAPPED)) {
- while (IS_SPACE_CHR(ldata->chars[nlpos.x - 1].chr) &&
+ while (nlpos.x &&
+ IS_SPACE_CHR(ldata->chars[nlpos.x - 1].chr) &&
+ !ldata->chars[nlpos.x - 1].cc_next &&
poslt(top, nlpos))
decpos(nlpos);
if (poslt(nlpos, bottom))
while (1) {
int uc = ldata->chars[x].chr;
+ attr = ldata->chars[x].attr;
switch (uc & CSET_MASK) {
case CSET_LINEDRW:
}
#endif
- for (p = cbuf; *p; p++) {
- /* Enough overhead for trailing NL and nul */
- if (wblen >= buflen - 16) {
- buflen += 100;
- workbuf = sresize(workbuf, buflen, wchar_t);
- wbptr = workbuf + wblen;
- }
- wblen++;
- *wbptr++ = *p;
- }
+ for (p = cbuf; *p; p++)
+ clip_addchar(&buf, *p, attr);
if (ldata->chars[x].cc_next)
x += ldata->chars[x].cc_next;
}
if (nl) {
int i;
- for (i = 0; i < sel_nl_sz; i++) {
- wblen++;
- *wbptr++ = sel_nl[i];
- }
+ for (i = 0; i < sel_nl_sz; i++)
+ clip_addchar(&buf, sel_nl[i], 0);
}
top.y++;
top.x = rect ? old_top_x : 0;
unlineptr(ldata);
}
#if SELECTION_NUL_TERMINATED
- wblen++;
- *wbptr++ = 0;
+ clip_addchar(&buf, 0, 0);
#endif
- write_clip(term->frontend, workbuf, wblen, desel); /* transfer to clipbd */
- if (buflen > 0) /* indicates we allocated this buffer */
- sfree(workbuf);
+ /* Finally, transfer all that to the clipboard. */
+ write_clip(term->frontend, buf.textbuf, buf.attrbuf, buf.bufpos, desel);
+ sfree(buf.textbuf);
+ sfree(buf.attrbuf);
}
void term_copyall(Terminal *term)
*/
if (!(ldata->lattr & LATTR_WRAPPED)) {
termchar *q = ldata->chars + term->cols;
- while (q > ldata->chars && IS_SPACE_CHR(q[-1].chr))
+ while (q > ldata->chars &&
+ IS_SPACE_CHR(q[-1].chr) && !q[-1].cc_next)
q--;
if (q == ldata->chars + term->cols)
q--;
x = term->cols - 1;
selpoint.y = y + term->disptop;
- selpoint.x = x;
ldata = lineptr(selpoint.y);
+
if ((ldata->lattr & LATTR_MODE) != LATTR_NORM)
- selpoint.x /= 2;
+ x /= 2;
+
+ /*
+ * Transform x through the bidi algorithm to find the _logical_
+ * click point from the physical one.
+ */
+ if (term_bidi_line(term, ldata, y) != NULL) {
+ x = term->post_bidi_cache[y].backward[x];
+ }
+
+ selpoint.x = x;
unlineptr(ldata);
- if (raw_mouse) {
+ /*
+ * If we're in the middle of a selection operation, we ignore raw
+ * mouse mode until it's done (we must have been not in raw mouse
+ * mode when it started).
+ * This makes use of Shift for selection reliable, and avoids the
+ * host seeing mouse releases for which they never saw corresponding
+ * presses.
+ */
+ if (raw_mouse &&
+ (term->selstate != ABOUT_TO) && (term->selstate != DRAGGING)) {
int encstate = 0, r, c;
char abuf[16];
if (!term->in_term_out) {
term->in_term_out = TRUE;
- term_blink(term, 1);
- term_out(term);
+ term_reset_cblink(term);
+ /*
+ * During drag-selects, we do not process terminal input,
+ * because the user will want the screen to hold still to
+ * be selected.
+ */
+ if (term->selstate != DRAGGING)
+ term_out(term);
term->in_term_out = FALSE;
}
* the remote side needing to wait until term_out() has cleared
* a backlog.
*
- * This is a slightly suboptimal way to deal with SSH2 - in
+ * This is a slightly suboptimal way to deal with SSH-2 - in
* principle, the window mechanism would allow us to continue
* to accept data on forwarded ports and X connections even
* while the terminal processing was going slowly - but we
* can't do the 100% right thing without moving the terminal
* processing into a separate thread, and that might hurt
- * portability. So we manage stdout buffering the old SSH1 way:
+ * portability. So we manage stdout buffering the old SSH-1 way:
* if the terminal processing goes slowly, the whole SSH
* connection stops accepting data until it's ready.
*
return 0;
}
+/*
+ * Write untrusted data to the terminal.
+ * The only control character that should be honoured is \n (which
+ * will behave as a CRLF).
+ */
+int term_data_untrusted(Terminal *term, const char *data, int len)
+{
+ int i;
+ /* FIXME: more sophisticated checking? */
+ for (i = 0; i < len; i++) {
+ if (data[i] == '\n')
+ term_data(term, 1, "\r\n", 2);
+ else if (data[i] & 0x60)
+ term_data(term, 1, data + i, 1);
+ }
+ return 0; /* assumes that term_data() always returns 0 */
+}
+
void term_provide_logctx(Terminal *term, void *logctx)
{
term->logctx = logctx;
}
+
+void term_set_focus(Terminal *term, int has_focus)
+{
+ term->has_focus = has_focus;
+ term_schedule_cblink(term);
+}
+
+/*
+ * Provide "auto" settings for remote tty modes, suitable for an
+ * application with a terminal window.
+ */
+char *term_get_ttymode(Terminal *term, const char *mode)
+{
+ char *val = NULL;
+ if (strcmp(mode, "ERASE") == 0) {
+ val = term->cfg.bksp_is_delete ? "^?" : "^H";
+ }
+ /* FIXME: perhaps we should set ONLCR based on cfg.lfhascr as well? */
+ return dupstr(val);
+}
+
+struct term_userpass_state {
+ size_t curr_prompt;
+ int done_prompt; /* printed out prompt yet? */
+ size_t pos; /* cursor position */
+};
+
+/*
+ * Process some terminal data in the course of username/password
+ * input.
+ */
+int term_get_userpass_input(Terminal *term, prompts_t *p,
+ unsigned char *in, int inlen)
+{
+ struct term_userpass_state *s = (struct term_userpass_state *)p->data;
+ if (!s) {
+ /*
+ * First call. Set some stuff up.
+ */
+ p->data = s = snew(struct term_userpass_state);
+ s->curr_prompt = 0;
+ s->done_prompt = 0;
+ /* We only print the `name' caption if we have to... */
+ if (p->name_reqd && p->name) {
+ size_t l = strlen(p->name);
+ term_data_untrusted(term, p->name, l);
+ if (p->name[l-1] != '\n')
+ term_data_untrusted(term, "\n", 1);
+ }
+ /* ...but we always print any `instruction'. */
+ if (p->instruction) {
+ size_t l = strlen(p->instruction);
+ term_data_untrusted(term, p->instruction, l);
+ if (p->instruction[l-1] != '\n')
+ term_data_untrusted(term, "\n", 1);
+ }
+ /*
+ * Zero all the results, in case we abort half-way through.
+ */
+ {
+ int i;
+ for (i = 0; i < (int)p->n_prompts; i++)
+ memset(p->prompts[i]->result, 0, p->prompts[i]->result_len);
+ }
+ }
+
+ while (s->curr_prompt < p->n_prompts) {
+
+ prompt_t *pr = p->prompts[s->curr_prompt];
+ int finished_prompt = 0;
+
+ if (!s->done_prompt) {
+ term_data_untrusted(term, pr->prompt, strlen(pr->prompt));
+ s->done_prompt = 1;
+ s->pos = 0;
+ }
+
+ /* Breaking out here ensures that the prompt is printed even
+ * if we're now waiting for user data. */
+ if (!in || !inlen) break;
+
+ /* FIXME: should we be using local-line-editing code instead? */
+ while (!finished_prompt && inlen) {
+ char c = *in++;
+ inlen--;
+ switch (c) {
+ case 10:
+ case 13:
+ term_data(term, 0, "\r\n", 2);
+ pr->result[s->pos] = '\0';
+ pr->result[pr->result_len - 1] = '\0';
+ /* go to next prompt, if any */
+ s->curr_prompt++;
+ s->done_prompt = 0;
+ finished_prompt = 1; /* break out */
+ break;
+ case 8:
+ case 127:
+ if (s->pos > 0) {
+ if (pr->echo)
+ term_data(term, 0, "\b \b", 3);
+ s->pos--;
+ }
+ break;
+ case 21:
+ case 27:
+ while (s->pos > 0) {
+ if (pr->echo)
+ term_data(term, 0, "\b \b", 3);
+ s->pos--;
+ }
+ break;
+ case 3:
+ case 4:
+ /* Immediate abort. */
+ term_data(term, 0, "\r\n", 2);
+ sfree(s);
+ p->data = NULL;
+ return 0; /* user abort */
+ default:
+ /*
+ * This simplistic check for printability is disabled
+ * when we're doing password input, because some people
+ * have control characters in their passwords.
+ */
+ if ((!pr->echo ||
+ (c >= ' ' && c <= '~') ||
+ ((unsigned char) c >= 160))
+ && s->pos < pr->result_len - 1) {
+ pr->result[s->pos++] = c;
+ if (pr->echo)
+ term_data(term, 0, &c, 1);
+ }
+ break;
+ }
+ }
+
+ }
+
+ if (s->curr_prompt < p->n_prompts) {
+ return -1; /* more data required */
+ } else {
+ sfree(s);
+ p->data = NULL;
+ return +1; /* all done */
+ }
+}
projects / u / mdw / putty / blobdiff