X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/c6f1b8ed877667ff8b75e5dda5a89cd54ffccfbb..HEAD:/terminal.c

diff --git a/terminal.c b/terminal.c
index 25c2cfda..113edc4f 100644
--- a/terminal.c
+++ b/terminal.c
@@ -1,3 +1,7 @@
+/*
+ * Terminal emulator.
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
@@ -43,6 +47,11 @@
 
 #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;			\
@@ -56,6 +65,8 @@
 
 #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))
@@ -89,10 +100,12 @@ static termline *lineptr(Terminal *, int, int, int);
 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 */
@@ -128,14 +141,13 @@ static void unlineptr(termline *line)
 	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)
 {
@@ -180,6 +192,7 @@ static void cc_check(termline *line)
 
     sfree(flags);
 }
+#endif
 
 /*
  * Add a combining character to a character cell.
@@ -226,7 +239,9 @@ static void add_cc(termline *line, int col, unsigned long chr)
     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
 }
 
 /*
@@ -252,7 +267,9 @@ static void clear_cc(termline *line, int col)
 
     line->chars[origcol].cc_next = 0;
 
-    cc_check(line);		       /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+    cc_check(line);
+#endif
 }
 
 /*
@@ -266,7 +283,7 @@ static int termchars_equal_override(termchar *a, termchar *b,
     /* 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)
@@ -300,7 +317,9 @@ static void copy_termchar(termline *destline, int x, termchar *src)
 	add_cc(destline, x, src->chr);
     }
 
-    cc_check(destline);		       /* XXX-REMOVE-BEFORE-RELEASE */
+#ifdef TERM_CC_DIAGS
+    cc_check(destline);
+#endif
 }
 
 /*
@@ -319,7 +338,9 @@ static void move_termchar(termline *line, termchar *dest, termchar *src)
     /* 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
 }
 
 /*
@@ -549,15 +570,39 @@ static void makeliteral_attr(struct buf *b, termchar *c, unsigned long *state)
      * 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)
@@ -640,9 +685,9 @@ static unsigned char *compressline(termline *ldata)
      * Diagnostics: ensure that the compressed data really does
      * decompress to the right thing.
      * 
-     * XXX-REMOVE-BEFORE-RELEASE: This is a bit performance-heavy
-     * to be leaving in production code.
+     * This is a bit performance-heavy for production code.
      */
+#ifdef TERM_CC_DIAGS
 #ifndef CHECK_SB_COMPRESSION
     {
 	int dused;
@@ -672,6 +717,7 @@ static unsigned char *compressline(termline *ldata)
 	freeline(dcl);
     }
 #endif
+#endif /* TERM_CC_DIAGS */
 
     /*
      * Trim the allocated memory so we don't waste any, and return.
@@ -753,18 +799,30 @@ static void readliteral_chr(struct buf *b, termchar *c, termline *ldata,
 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)
@@ -919,7 +977,9 @@ static void resizeline(Terminal *term, termline *line, int cols)
 	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
     }
 }
 
@@ -929,7 +989,7 @@ static void resizeline(Terminal *term, termline *line, int cols)
 static int sblines(Terminal *term)
 {
     int sblines = count234(term->scrollback);
-    if (term->cfg.erase_to_scrollback &&
+    if (term->erase_to_scrollback &&
 	term->alt_which && term->alt_screen) {
 	    sblines += term->alt_sblines;
     }
@@ -955,7 +1015,7 @@ static termline *lineptr(Terminal *term, int y, int lineno, int screen)
 
 	assert(!screen);
 
-	if (term->cfg.erase_to_scrollback &&
+	if (term->erase_to_scrollback &&
 	    term->alt_which && term->alt_screen) {
 	    altlines = term->alt_sblines;
 	}
@@ -976,6 +1036,21 @@ static termline *lineptr(Terminal *term, int y, int lineno, int screen)
     }
 
     /* 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);
@@ -987,14 +1062,131 @@ static termline *lineptr(Terminal *term, int y, int lineno, int screen)
 #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, unsigned long now)
+{
+    Terminal *term = (Terminal *)ctx;
+    int update = FALSE;
+
+    if (term->tblink_pending && now == term->next_tblink) {
+	term->tblinker = !term->tblinker;
+	term->tblink_pending = FALSE;
+	term_schedule_tblink(term);
+	update = TRUE;
+    }
+
+    if (term->cblink_pending && now == term->next_cblink) {
+	term->cblinker = !term->cblinker;
+	term->cblink_pending = FALSE;
+	term_schedule_cblink(term);
+	update = TRUE;
+    }
+
+    if (term->in_vbell && now == term->vbell_end) {
+	term->in_vbell = FALSE;
+	update = TRUE;
+    }
+
+    if (update ||
+	(term->window_update_pending && now == term->next_update))
+	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->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;
@@ -1005,39 +1197,59 @@ 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 = term->cfg.dec_om;
+    term->alt_om = term->dec_om = conf_get_int(term->conf, CONF_dec_om);
     term->alt_ins = term->insert = FALSE;
-    term->alt_wnext = term->wrapnext = term->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_wnext = term->wrapnext =
+        term->save_wnext = term->alt_save_wnext = FALSE;
+    term->alt_wrap = term->wrap = conf_get_int(term->conf, CONF_wrap_mode);
+    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;
-    term->use_bce = term->cfg.bce;
-    term->blink_is_real = term->cfg.blinktext;
+    term->app_cursor_keys = conf_get_int(term->conf, CONF_app_cursor);
+    term->app_keypad_keys = conf_get_int(term->conf, CONF_app_keypad);
+    term->use_bce = conf_get_int(term->conf, CONF_bce);
+    term->blink_is_real = conf_get_int(term->conf, CONF_blinktext);
     term->erase_char = term->basic_erase_char;
     term->alt_which = 0;
     term_print_finish(term);
+    term->xterm_mouse = 0;
+    term->xterm_extended_mouse = 0;
+    term->urxvt_extended_mouse = 0;
+    set_raw_mouse_mode(term->frontend, FALSE);
+    term->bracketed_paste = FALSE;
     {
 	int i;
 	for (i = 0; i < 256; i++)
-	    term->wordness[i] = term->cfg.wordness[i];
+	    term->wordness[i] = conf_get_int_int(term->conf, CONF_wordness, i);
     }
     if (term->screen) {
 	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);
 }
 
 /*
@@ -1046,10 +1258,13 @@ static void power_on(Terminal *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->seen_disp_event && term->cfg.scroll_on_disp) {
+	if (term->seen_disp_event && term->scroll_on_disp) {
 	    term->disptop = 0;	       /* return to main screen */
 	    term->seen_disp_event = 0;
 	    need_sbar_update = TRUE;
@@ -1088,18 +1303,18 @@ void term_seen_key_event(Terminal *term)
     /*
      * Reset the scrollback on keypress, if we're doing that.
      */
-    if (term->cfg.scroll_on_key) {
+    if (term->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;
@@ -1116,12 +1331,82 @@ static void set_erase_char(Terminal *term)
 }
 
 /*
+ * We copy a bunch of stuff out of the Conf structure into local
+ * fields in the Terminal structure, to avoid the repeated tree234
+ * lookups which would be involved in fetching them from the former
+ * every time.
+ */
+void term_copy_stuff_from_conf(Terminal *term)
+{
+    term->ansi_colour = conf_get_int(term->conf, CONF_ansi_colour);
+    term->arabicshaping = conf_get_int(term->conf, CONF_arabicshaping);
+    term->beep = conf_get_int(term->conf, CONF_beep);
+    term->bellovl = conf_get_int(term->conf, CONF_bellovl);
+    term->bellovl_n = conf_get_int(term->conf, CONF_bellovl_n);
+    term->bellovl_s = conf_get_int(term->conf, CONF_bellovl_s);
+    term->bellovl_t = conf_get_int(term->conf, CONF_bellovl_t);
+    term->bidi = conf_get_int(term->conf, CONF_bidi);
+    term->bksp_is_delete = conf_get_int(term->conf, CONF_bksp_is_delete);
+    term->blink_cur = conf_get_int(term->conf, CONF_blink_cur);
+    term->blinktext = conf_get_int(term->conf, CONF_blinktext);
+    term->cjk_ambig_wide = conf_get_int(term->conf, CONF_cjk_ambig_wide);
+    term->conf_height = conf_get_int(term->conf, CONF_height);
+    term->conf_width = conf_get_int(term->conf, CONF_width);
+    term->crhaslf = conf_get_int(term->conf, CONF_crhaslf);
+    term->erase_to_scrollback = conf_get_int(term->conf, CONF_erase_to_scrollback);
+    term->funky_type = conf_get_int(term->conf, CONF_funky_type);
+    term->lfhascr = conf_get_int(term->conf, CONF_lfhascr);
+    term->logflush = conf_get_int(term->conf, CONF_logflush);
+    term->logtype = conf_get_int(term->conf, CONF_logtype);
+    term->mouse_override = conf_get_int(term->conf, CONF_mouse_override);
+    term->nethack_keypad = conf_get_int(term->conf, CONF_nethack_keypad);
+    term->no_alt_screen = conf_get_int(term->conf, CONF_no_alt_screen);
+    term->no_applic_c = conf_get_int(term->conf, CONF_no_applic_c);
+    term->no_applic_k = conf_get_int(term->conf, CONF_no_applic_k);
+    term->no_dbackspace = conf_get_int(term->conf, CONF_no_dbackspace);
+    term->no_mouse_rep = conf_get_int(term->conf, CONF_no_mouse_rep);
+    term->no_remote_charset = conf_get_int(term->conf, CONF_no_remote_charset);
+    term->no_remote_resize = conf_get_int(term->conf, CONF_no_remote_resize);
+    term->no_remote_wintitle = conf_get_int(term->conf, CONF_no_remote_wintitle);
+    term->rawcnp = conf_get_int(term->conf, CONF_rawcnp);
+    term->rect_select = conf_get_int(term->conf, CONF_rect_select);
+    term->remote_qtitle_action = conf_get_int(term->conf, CONF_remote_qtitle_action);
+    term->rxvt_homeend = conf_get_int(term->conf, CONF_rxvt_homeend);
+    term->scroll_on_disp = conf_get_int(term->conf, CONF_scroll_on_disp);
+    term->scroll_on_key = conf_get_int(term->conf, CONF_scroll_on_key);
+    term->xterm_256_colour = conf_get_int(term->conf, CONF_xterm_256_colour);
+
+    /*
+     * Parse the control-character escapes in the configured
+     * answerback string.
+     */
+    {
+	char *answerback = conf_get_str(term->conf, CONF_answerback);
+	int maxlen = strlen(answerback);
+
+	term->answerback = snewn(maxlen, char);
+	term->answerbacklen = 0;
+
+	while (*answerback) {
+	    char *n;
+	    char c = ctrlparse(answerback, &n);
+	    if (n) {
+		term->answerback[term->answerbacklen++] = c;
+		answerback = n;
+	    } else {
+		term->answerback[term->answerbacklen++] = *answerback++;
+	    }
+	}
+    }
+}
+
+/*
  * When the user reconfigures us, we need to check the forbidden-
  * alternate-screen config option, disable raw mouse mode if the
  * user has disabled mouse reporting, and abandon a print job if
  * the user has disabled printing.
  */
-void term_reconfig(Terminal *term, Config *cfg)
+void term_reconfig(Terminal *term, Conf *conf)
 {
     /*
      * Before adopting the new config, check all those terminal
@@ -1130,24 +1415,31 @@ void term_reconfig(Terminal *term, Config *cfg)
      * 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_wrap = (conf_get_int(term->conf, CONF_wrap_mode) !=
+		  conf_get_int(conf, CONF_wrap_mode));
+    reset_decom = (conf_get_int(term->conf, CONF_dec_om) !=
+		   conf_get_int(conf, CONF_dec_om));
+    reset_bce = (conf_get_int(term->conf, CONF_bce) !=
+		 conf_get_int(conf, CONF_bce));
+    reset_tblink = (conf_get_int(term->conf, CONF_blinktext) !=
+		    conf_get_int(conf, CONF_blinktext));
     reset_charclass = 0;
-    for (i = 0; i < lenof(term->cfg.wordness); i++)
-	if (term->cfg.wordness[i] != cfg->wordness[i])
+    for (i = 0; i < 256; i++)
+	if (conf_get_int_int(term->conf, CONF_wordness, i) !=
+	    conf_get_int_int(conf, CONF_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) {
+    if (conf_get_int(term->conf, CONF_arabicshaping) !=
+	conf_get_int(conf, CONF_arabicshaping) ||
+	conf_get_int(term->conf, CONF_bidi) !=
+	conf_get_int(conf, CONF_bidi)) {
 	for (i = 0; i < term->bidi_cache_size; i++) {
 	    sfree(term->pre_bidi_cache[i].chars);
 	    sfree(term->post_bidi_cache[i].chars);
@@ -1158,36 +1450,41 @@ void term_reconfig(Terminal *term, Config *cfg)
 	}
     }
 
-    term->cfg = *cfg;		       /* STRUCTURE COPY */
+    conf_free(term->conf);
+    term->conf = conf_copy(conf);
 
     if (reset_wrap)
-	term->alt_wrap = term->wrap = term->cfg.wrap_mode;
+	term->alt_wrap = term->wrap = conf_get_int(term->conf, CONF_wrap_mode);
     if (reset_decom)
-	term->alt_om = term->dec_om = term->cfg.dec_om;
+	term->alt_om = term->dec_om = conf_get_int(term->conf, CONF_dec_om);
     if (reset_bce) {
-	term->use_bce = term->cfg.bce;
+	term->use_bce = conf_get_int(term->conf, CONF_bce);
 	set_erase_char(term);
     }
-    if (reset_blink)
-	term->blink_is_real = term->cfg.blinktext;
+    if (reset_tblink) {
+	term->blink_is_real = conf_get_int(term->conf, CONF_blinktext);
+    }
     if (reset_charclass)
 	for (i = 0; i < 256; i++)
-	    term->wordness[i] = term->cfg.wordness[i];
+	    term->wordness[i] = conf_get_int_int(term->conf, CONF_wordness, i);
 
-    if (term->cfg.no_alt_screen)
+    if (conf_get_int(term->conf, CONF_no_alt_screen))
 	swap_screen(term, 0, FALSE, FALSE);
-    if (term->cfg.no_mouse_rep) {
+    if (conf_get_int(term->conf, CONF_no_mouse_rep)) {
 	term->xterm_mouse = 0;
 	set_raw_mouse_mode(term->frontend, 0);
     }
-    if (term->cfg.no_remote_charset) {
+    if (conf_get_int(term->conf, CONF_no_remote_charset)) {
 	term->cset_attr[0] = term->cset_attr[1] = CSET_ASCII;
 	term->sco_acs = term->alt_sco_acs = 0;
 	term->utf = 0;
     }
-    if (!*term->cfg.printer) {
+    if (!conf_get_str(term->conf, CONF_printer)) {
 	term_print_finish(term);
     }
+    term_schedule_tblink(term);
+    term_schedule_cblink(term);
+    term_copy_stuff_from_conf(term);
 }
 
 /*
@@ -1195,7 +1492,7 @@ void term_reconfig(Terminal *term, Config *cfg)
  */
 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 */
@@ -1208,7 +1505,7 @@ void term_clrsb(Terminal *term)
 /*
  * Initialise the terminal.
  */
-Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,
+Terminal *term_init(Conf *myconf, struct unicode_data *ucsdata,
 		    void *frontend)
 {
     Terminal *term;
@@ -1220,11 +1517,11 @@ Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,
     term = snew(Terminal);
     term->frontend = frontend;
     term->ucsdata = ucsdata;
-    term->cfg = *mycfg;		       /* STRUCTURE COPY */
+    term->conf = conf_copy(myconf);
     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;
@@ -1235,15 +1532,17 @@ Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,
     term->vt52_mode = FALSE;
     term->cr_lf_return = FALSE;
     term->seen_disp_event = FALSE;
-    term->xterm_mouse = term->mouse_is_down = FALSE;
+    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->selstate = NO_SELECTION;
     term->curstype = 0;
 
+    term_copy_stuff_from_conf(term);
+
     term->screen = term->alt_screen = term->scrollback = NULL;
     term->tempsblines = 0;
     term->alt_sblines = 0;
@@ -1253,7 +1552,7 @@ Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,
     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;
@@ -1271,6 +1570,8 @@ Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,
     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;
 
@@ -1320,10 +1621,18 @@ void term_free(Terminal *term)
     for (i = 0; i < term->bidi_cache_size; i++) {
 	sfree(term->pre_bidi_cache[i].chars);
 	sfree(term->post_bidi_cache[i].chars);
+        sfree(term->post_bidi_cache[i].forward);
+        sfree(term->post_bidi_cache[i].backward);
     }
     sfree(term->pre_bidi_cache);
     sfree(term->post_bidi_cache);
 
+    sfree(term->tabs);
+
+    expire_timer_context(term);
+
+    conf_free(term->conf);
+
     sfree(term);
 }
 
@@ -1342,6 +1651,11 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
 	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);
 
@@ -1390,6 +1704,8 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
 	    addpos234(term->screen, line, 0);
 	    term->curs.y += 1;
 	    term->savecurs.y += 1;
+	    term->alt_y += 1;
+	    term->alt_savecurs.y += 1;
 	} else {
 	    /* Add a new blank line at the bottom of the screen. */
 	    line = newline(term, newcols, FALSE);
@@ -1401,7 +1717,8 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
     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));
+            line = delpos234(term->screen, term->rows - 1);
+            freeline(line);
 	} else {
 	    /* push top row to scrollback */
 	    line = delpos234(term->screen, 0);
@@ -1410,6 +1727,8 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
 	    term->tempsblines += 1;
 	    term->curs.y -= 1;
 	    term->savecurs.y -= 1;
+	    term->alt_y -= 1;
+	    term->alt_savecurs.y -= 1;
 	}
 	term->rows -= 1;
     }
@@ -1433,7 +1752,7 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
     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++)
@@ -1469,12 +1788,26 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines)
 	term->savecurs.y = 0;
     if (term->savecurs.y >= newrows)
 	term->savecurs.y = newrows - 1;
+    if (term->savecurs.x >= newcols)
+	term->savecurs.x = newcols - 1;
+    if (term->alt_savecurs.y < 0)
+	term->alt_savecurs.y = 0;
+    if (term->alt_savecurs.y >= newrows)
+	term->alt_savecurs.y = newrows - 1;
+    if (term->alt_savecurs.x >= newcols)
+	term->alt_savecurs.x = newcols - 1;
     if (term->curs.y < 0)
 	term->curs.y = 0;
     if (term->curs.y >= newrows)
 	term->curs.y = newrows - 1;
     if (term->curs.x >= newcols)
 	term->curs.x = newcols - 1;
+    if (term->alt_y < 0)
+	term->alt_y = 0;
+    if (term->alt_y >= newrows)
+	term->alt_y = newrows - 1;
+    if (term->alt_x >= newcols)
+	term->alt_x = newcols - 1;
     term->alt_x = term->alt_y = 0;
     term->wrapnext = term->alt_wnext = FALSE;
 
@@ -1500,7 +1833,7 @@ void term_provide_resize_fn(Terminal *term,
 {
     term->resize_fn = resize_fn;
     term->resize_ctx = resize_ctx;
-    if (term->cols > 0 && term->rows > 0)
+    if (resize_fn && term->cols > 0 && term->rows > 0)
 	resize_fn(resize_ctx, term->cols, term->rows);
 }
 
@@ -1532,6 +1865,7 @@ static int find_last_nonempty_line(Terminal * term, tree234 * screen)
 static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos)
 {
     int t;
+    pos tp;
     tree234 *ttr;
 
     if (!which)
@@ -1579,6 +1913,35 @@ static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos)
 	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) {
@@ -1617,15 +1980,26 @@ static void check_selection(Terminal *term, pos from, pos to)
 static void scroll(Terminal *term, int topline, int botline, int lines, int sb)
 {
     termline *line;
-    int i, seltop, olddisptop, shift;
+    int i, seltop, scrollwinsize;
+#ifdef OPTIMISE_SCROLL
+    int olddisptop, shift;
+#endif /* OPTIMISE_SCROLL */
 
     if (topline != 0 || term->alt_which != 0)
 	sb = FALSE;
 
+#ifdef OPTIMISE_SCROLL
     olddisptop = term->disptop;
     shift = lines;
+#endif /* OPTIMISE_SCROLL */
+
+    scrollwinsize = botline - topline + 1;
+
     if (lines < 0) {
-	while (lines < 0) {
+        lines = -lines;
+        if (lines > scrollwinsize)
+            lines = scrollwinsize;
+	while (lines-- > 0) {
 	    line = delpos234(term->screen, botline);
             resizeline(term, line, term->cols);
 	    for (i = 0; i < term->cols; i++)
@@ -1647,13 +2021,15 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb)
 		    term->selend.x = 0;
 		}
 	    }
-
-	    lines++;
 	}
     } else {
-	while (lines > 0) {
+        if (lines > scrollwinsize)
+            lines = scrollwinsize;
+	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);
 		/*
@@ -1735,8 +2111,6 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb)
 		    }
 		}
 	    }
-
-	    lines--;
 	}
     }
 #ifdef OPTIMISE_SCROLL
@@ -1788,27 +2162,27 @@ static void scroll_display(Terminal *term, int topline, int botline, int lines)
     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);
 }
@@ -1964,7 +2338,7 @@ static void erase_lots(Terminal *term,
     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 (term->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. */
@@ -2044,8 +2418,6 @@ static void insch(Terminal *term, int n)
  */
 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 */
@@ -2057,12 +2429,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 = term->cfg.blinktext;
+		term->blink_is_real = term->blinktext;
 	    }
+	    term_schedule_tblink(term);
 	    break;
 	  case 3:		       /* DECCOLM: 80/132 columns */
 	    deselect(term);
-	    if (!term->cfg.no_remote_resize)
+	    if (!term->no_remote_resize)
 		request_resize(term->frontend, state ? 132 : 80, term->rows);
 	    term->reset_132 = state;
 	    term->alt_t = term->marg_t = 0;
@@ -2077,27 +2450,15 @@ static void toggle_mode(Terminal *term, int mode, int query, int state)
 	     * 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;
@@ -2116,44 +2477,53 @@ static void toggle_mode(Terminal *term, int mode, int query, int 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);
 	    deselect(term);
-	    swap_screen(term, term->cfg.no_alt_screen ? 0 : state, FALSE, FALSE);
+	    swap_screen(term, term->no_alt_screen ? 0 : state, FALSE, FALSE);
 	    term->disptop = 0;
 	    break;
-	  case 1000:		       /* xterm mouse 1 */
+	  case 1000:		       /* xterm mouse 1 (normal) */
 	    term->xterm_mouse = state ? 1 : 0;
 	    set_raw_mouse_mode(term->frontend, state);
 	    break;
-	  case 1002:		       /* xterm mouse 2 */
+	  case 1002:		       /* xterm mouse 2 (inc. button drags) */
 	    term->xterm_mouse = state ? 2 : 0;
 	    set_raw_mouse_mode(term->frontend, state);
 	    break;
+	  case 1006:		       /* xterm extended mouse */
+	    term->xterm_extended_mouse = state ? 1 : 0;
+	    break;
+	  case 1015:		       /* urxvt extended mouse */
+	    term->urxvt_extended_mouse = state ? 1 : 0;
+	    break;
 	  case 1047:                   /* alternate screen */
 	    compatibility(OTHER);
 	    deselect(term);
-	    swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, TRUE);
+	    swap_screen(term, term->no_alt_screen ? 0 : state, TRUE, TRUE);
 	    term->disptop = 0;
 	    break;
 	  case 1048:                   /* save/restore cursor */
-	    if (!term->cfg.no_alt_screen)
+	    if (!term->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)
+	    if (state && !term->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);
-	    if (!state && !term->cfg.no_alt_screen)
+	    swap_screen(term, term->no_alt_screen ? 0 : state, TRUE, FALSE);
+	    if (!state && !term->no_alt_screen)
 		save_cursor(term, state);
 	    term->disptop = 0;
 	    break;
+	  case 2004:		       /* xterm bracketed paste */
+	    term->bracketed_paste = state ? TRUE : FALSE;
+	    break;
     } else
 	switch (mode) {
 	  case 4:		       /* IRM: set insert mode */
@@ -2188,14 +2558,14 @@ static void do_osc(Terminal *term)
 	switch (term->esc_args[0]) {
 	  case 0:
 	  case 1:
-	    if (!term->cfg.no_remote_wintitle)
+	    if (!term->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 (!term->cfg.no_remote_wintitle)
+	    if (!term->no_remote_wintitle)
 		set_title(term->frontend, term->osc_string);
 	    break;
 	}
@@ -2205,10 +2575,10 @@ static void do_osc(Terminal *term)
 /*
  * ANSI printing routines.
  */
-static void term_print_setup(Terminal *term)
+static void term_print_setup(Terminal *term, char *printer)
 {
     bufchain_clear(&term->printer_buf);
-    term->print_job = printer_start_job(term->cfg.printer);
+    term->print_job = printer_start_job(printer);
 }
 static void term_print_flush(Terminal *term)
 {
@@ -2254,7 +2624,7 @@ static void term_print_finish(Terminal *term)
  * 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;
@@ -2264,7 +2634,7 @@ void term_out(Terminal *term)
     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;
@@ -2283,7 +2653,7 @@ void term_out(Terminal *term)
 	     * Optionally log the session traffic to a file. Useful for
 	     * debugging and possibly also useful for actual logging.
 	     */
-	    if (term->cfg.logtype == LGTYP_DEBUG && term->logctx)
+	    if (term->logtype == LGTYP_DEBUG && term->logctx)
 		logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG);
 	} else {
 	    c = unget;
@@ -2454,12 +2824,19 @@ void term_out(Terminal *term)
 	    }
 	}
 
-	/* 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. */
@@ -2468,7 +2845,7 @@ void term_out(Terminal *term)
 		term->curs.x--;
 	    term->wrapnext = FALSE;
 	    /* destructive backspace might be disabled */
-	    if (!term->cfg.no_dbackspace) {
+	    if (!term->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),
@@ -2479,35 +2856,17 @@ void term_out(Terminal *term)
 	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;
-		    }
 		    lpage_send(term->ldisc, DEFAULT_CODEPAGE,
-			       abuf, d - abuf, 0);
+			       term->answerback, term->answerbacklen, 0);
 		}
 		break;
 	      case '\007':	      /* BEL: Bell */
@@ -2534,7 +2893,7 @@ void term_out(Terminal *term)
 		     * t seconds ago.
 		     */
 		    while (term->beephead &&
-			   term->beephead->ticks < ticks - term->cfg.bellovl_t) {
+			   term->beephead->ticks < ticks - term->bellovl_t) {
 			struct beeptime *tmp = term->beephead;
 			term->beephead = tmp->next;
 			sfree(tmp);
@@ -2543,16 +2902,16 @@ void term_out(Terminal *term)
 			term->nbeeps--;
 		    }
 
-		    if (term->cfg.bellovl && term->beep_overloaded &&
-			ticks - term->lastbeep >= (unsigned)term->cfg.bellovl_s) {
+		    if (term->bellovl && term->beep_overloaded &&
+			ticks - term->lastbeep >= (unsigned)term->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 (term->cfg.bellovl && !term->beep_overloaded &&
-			       term->nbeeps >= term->cfg.bellovl_n) {
+		    } else if (term->bellovl && !term->beep_overloaded &&
+			       term->nbeeps >= term->bellovl_n) {
 			/*
 			 * Now, if we have n or more beeps
 			 * remaining in the queue, go into overload
@@ -2565,15 +2924,14 @@ void term_out(Terminal *term)
 		    /*
 		     * Perform an actual beep if we're not overloaded.
 		     */
-		    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);
+		    if (!term->bellovl || !term->beep_overloaded) {
+			do_beep(term->frontend, term->beep);
+
+			if (term->beep == BELL_VISUAL) {
+			    term_schedule_vbell(term, FALSE, 0);
 			}
 		    }
-		    term->seen_disp_event = TRUE;
+		    seen_disp_event(term);
 		}
 		break;
 	      case '\b':	      /* BS: Back space */
@@ -2586,7 +2944,7 @@ void term_out(Terminal *term)
 		    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);
@@ -2608,8 +2966,15 @@ void term_out(Terminal *term)
 	      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->crhaslf) {
+		    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 (term->logctx)
 		    logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);
 		break;
@@ -2619,7 +2984,7 @@ void term_out(Terminal *term)
 		    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 */
@@ -2629,10 +2994,10 @@ void term_out(Terminal *term)
 		    scroll(term, term->marg_t, term->marg_b, 1, TRUE);
 		else if (term->curs.y < term->rows - 1)
 		    term->curs.y++;
-		if (term->cfg.lfhascr)
+		if (term->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);
@@ -2657,7 +3022,7 @@ void term_out(Terminal *term)
 
 		    check_selection(term, old_curs, term->curs);
 		}
-		term->seen_disp_event = TRUE;
+		seen_disp_event(term);
 		break;
 	    }
 	} else
@@ -2671,7 +3036,9 @@ void term_out(Terminal *term)
 		    if (DIRECT_CHAR(c))
 			width = 1;
 		    if (!width)
-			width = wcwidth((wchar_t) c);
+			width = (term->cjk_ambig_wide ?
+				 mk_wcwidth_cjk((unsigned int) c) :
+				 mk_wcwidth((unsigned int) c));
 
 		    if (term->wrapnext && term->wrap && width > 0) {
 			cline->lattr |= LATTR_WRAPPED;
@@ -2729,6 +3096,7 @@ void term_out(Terminal *term)
 			    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);
@@ -2776,7 +3144,7 @@ void term_out(Terminal *term)
 			    }
 
 			    add_cc(cline, x, c);
-			    term->seen_disp_event = 1;
+			    seen_disp_event(term);
 			}
 			continue;
 		      default:
@@ -2796,7 +3164,7 @@ void term_out(Terminal *term)
 			    term->wrapnext = FALSE;
 			}
 		    }
-		    term->seen_disp_event = 1;
+		    seen_disp_event(term);
 		}
 		break;
 
@@ -2841,7 +3209,7 @@ void term_out(Terminal *term)
 		  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);
@@ -2858,7 +3226,7 @@ void term_out(Terminal *term)
 		    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);
@@ -2868,7 +3236,7 @@ void term_out(Terminal *term)
 		    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);
@@ -2877,7 +3245,7 @@ void term_out(Terminal *term)
 		    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);
@@ -2887,16 +3255,16 @@ void term_out(Terminal *term)
 		    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) {
-			if (!term->cfg.no_remote_resize)
+			if (!term->no_remote_resize)
 			    request_resize(term->frontend, 80, term->rows);
 			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);
@@ -2920,7 +3288,7 @@ void term_out(Terminal *term)
 			    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;
@@ -2956,55 +3324,55 @@ void term_out(Terminal *term)
 		  /* GZD4: G0 designate 94-set */
 		  case ANSI('A', '('):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[0] = CSET_GBCHR;
 		    break;
 		  case ANSI('B', '('):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[0] = CSET_ASCII;
 		    break;
 		  case ANSI('0', '('):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[0] = CSET_LINEDRW;
 		    break;
 		  case ANSI('U', '('): 
 		    compatibility(OTHER);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[0] = CSET_SCOACS; 
 		    break;
 		  /* G1D4: G1-designate 94-set */
 		  case ANSI('A', ')'):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[1] = CSET_GBCHR;
 		    break;
 		  case ANSI('B', ')'):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[1] = CSET_ASCII;
 		    break;
 		  case ANSI('0', ')'):
 		    compatibility(VT100);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[1] = CSET_LINEDRW;
 		    break;
 		  case ANSI('U', ')'): 
 		    compatibility(OTHER);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->cset_attr[1] = CSET_SCOACS; 
 		    break;
 		  /* DOCS: Designate other coding system */
 		  case ANSI('8', '%'):	/* Old Linux code */
 		  case ANSI('G', '%'):
 		    compatibility(OTHER);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->utf = 1;
 		    break;
 		  case ANSI('@', '%'):
 		    compatibility(OTHER);
-		    if (!term->cfg.no_remote_charset)
+		    if (!term->no_remote_charset)
 			term->utf = 0;
 		    break;
 		}
@@ -3020,8 +3388,8 @@ void term_out(Terminal *term)
 		    }
 		    term->termstate = SEEN_CSI;
 		} else if (c == ';') {
-		    if (++term->esc_nargs <= ARGS_MAX)
-			term->esc_args[term->esc_nargs - 1] = ARG_DEFAULT;
+		    if (term->esc_nargs < ARGS_MAX)
+			term->esc_args[term->esc_nargs++] = ARG_DEFAULT;
 		    term->termstate = SEEN_CSI;
 		} else if (c < '@') {
 		    if (term->esc_query)
@@ -3036,7 +3404,7 @@ void term_out(Terminal *term)
 		      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);
@@ -3044,7 +3412,7 @@ void term_out(Terminal *term)
 		      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);
@@ -3059,31 +3427,31 @@ void term_out(Terminal *term)
 		      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);
@@ -3091,7 +3459,7 @@ void term_out(Terminal *term)
 			     ((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 */
@@ -3101,17 +3469,24 @@ void term_out(Terminal *term)
 			     ((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 */
 			{
@@ -3120,14 +3495,14 @@ void term_out(Terminal *term)
 				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);
@@ -3135,18 +3510,18 @@ void term_out(Terminal *term)
 			    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);
@@ -3181,12 +3556,15 @@ void term_out(Terminal *term)
 		      case ANSI_QUE('i'):
 			compatibility(VT100);
 			{
+			    char *printer;
 			    if (term->esc_nargs != 1) break;
-			    if (term->esc_args[0] == 5 && *term->cfg.printer) {
+			    if (term->esc_args[0] == 5 && 
+				(printer = conf_get_str(term->conf,
+							CONF_printer))[0]) {
 				term->printing = TRUE;
 				term->only_printing = !term->esc_query;
 				term->print_state = 0;
-				term_print_setup(term);
+				term_print_setup(term, printer);
 			    } else if (term->esc_args[0] == 4 &&
 				       term->printing) {
 				term_print_finish(term);
@@ -3244,7 +3622,7 @@ void term_out(Terminal *term)
 				 */
 				term->curs.y = (term->dec_om ?
 						term->marg_t : 0);
-				term->seen_disp_event = TRUE;
+				seen_disp_event(term);
 			    }
 			}
 			break;
@@ -3302,21 +3680,22 @@ void term_out(Terminal *term)
 				    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;
 				    break;
 				  case 10:      /* SCO acs off */
 				    compatibility(SCOANSI);
-				    if (term->cfg.no_remote_charset) break;
+				    if (term->no_remote_charset) break;
 				    term->sco_acs = 0; break;
 				  case 11:      /* SCO acs on */
 				    compatibility(SCOANSI);
-				    if (term->cfg.no_remote_charset) break;
+				    if (term->no_remote_charset) break;
 				    term->sco_acs = 1; break;
 				  case 12:      /* SCO acs on, |0x80 */
 				    compatibility(SCOANSI);
-				    if (term->cfg.no_remote_charset) break;
+				    if (term->no_remote_charset) break;
 				    term->sco_acs = 2; break;
 				  case 22:	/* disable bold */
 				    compatibility2(OTHER, VT220);
@@ -3355,10 +3734,10 @@ void term_out(Terminal *term)
 				  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 */
@@ -3386,16 +3765,36 @@ void term_out(Terminal *term)
 				  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);
@@ -3406,7 +3805,7 @@ void term_out(Terminal *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 */
 			/*
@@ -3419,7 +3818,7 @@ void term_out(Terminal *term)
 			    && (term->esc_args[0] < 1 ||
 				term->esc_args[0] >= 24)) {
 			    compatibility(VT340TEXT);
-			    if (!term->cfg.no_remote_resize)
+			    if (!term->no_remote_resize)
 				request_resize(term->frontend, term->cols,
 					       def(term->esc_args[0], 24));
 			    deselect(term);
@@ -3439,7 +3838,7 @@ void term_out(Terminal *term)
 				break;
 			      case 3:
 				if (term->esc_nargs >= 3) {
-				    if (!term->cfg.no_remote_resize)
+				    if (!term->no_remote_resize)
 					move_window(term->frontend,
 						    def(term->esc_args[1], 0),
 						    def(term->esc_args[2], 0));
@@ -3464,10 +3863,10 @@ void term_out(Terminal *term)
 				break;
 			      case 8:
 				if (term->esc_nargs >= 3) {
-				    if (!term->cfg.no_remote_resize)
+				    if (!term->no_remote_resize)
 					request_resize(term->frontend,
-						       def(term->esc_args[2], term->cfg.width),
-						       def(term->esc_args[1], term->cfg.height));
+						       def(term->esc_args[2], term->conf_width),
+						       def(term->esc_args[1], term->conf_height));
 				}
 				break;
 			      case 9:
@@ -3480,7 +3879,7 @@ void term_out(Terminal *term)
 				if (term->ldisc)
 				    ldisc_send(term->ldisc,
 					       is_iconic(term->frontend) ?
-					       "\033[1t" : "\033[2t", 4, 0);
+					       "\033[2t" : "\033[1t", 4, 0);
 				break;
 			      case 13:
 				if (term->ldisc) {
@@ -3492,7 +3891,7 @@ void term_out(Terminal *term)
 			      case 14:
 				if (term->ldisc) {
 				    get_window_pixels(term->frontend, &x, &y);
-				    len = sprintf(buf, "\033[4;%d;%dt", x, y);
+				    len = sprintf(buf, "\033[4;%d;%dt", y, x);
 				    ldisc_send(term->ldisc, buf, len, 0);
 				}
 				break;
@@ -3522,8 +3921,11 @@ void term_out(Terminal *term)
 				break;
 			      case 20:
 				if (term->ldisc &&
-				    !term->cfg.no_remote_qtitle) {
-				    p = get_window_title(term->frontend, TRUE);
+				    term->remote_qtitle_action != TITLE_NONE) {
+				    if(term->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);
@@ -3532,8 +3934,11 @@ void term_out(Terminal *term)
 				break;
 			      case 21:
 				if (term->ldisc &&
-				    !term->cfg.no_remote_qtitle) {
-				    p = get_window_title(term->frontend,FALSE);
+				    term->remote_qtitle_action != TITLE_NONE) {
+				    if(term->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);
@@ -3548,14 +3953,14 @@ void term_out(Terminal *term)
 			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 */
 			/* 
@@ -3566,10 +3971,10 @@ void term_out(Terminal *term)
 			 */
 			compatibility(VT420);
 			if (term->esc_nargs == 1 && term->esc_args[0] > 0) {
-			    if (!term->cfg.no_remote_resize)
+			    if (!term->no_remote_resize)
 				request_resize(term->frontend, term->cols,
 					       def(term->esc_args[0],
-						   term->cfg.height));
+						   term->conf_height));
 			    deselect(term);
 			}
 			break;
@@ -3581,10 +3986,11 @@ void term_out(Terminal *term)
 			 */
 			compatibility(VT340TEXT);
 			if (term->esc_nargs <= 1) {
-			    if (!term->cfg.no_remote_resize)
+			    if (!term->no_remote_resize)
 				request_resize(term->frontend,
 					       def(term->esc_args[0],
-						   term->cfg.width), term->rows);
+						   term->conf_width),
+					       term->rows);
 			    deselect(term);
 			}
 			break;
@@ -3608,7 +4014,7 @@ void term_out(Terminal *term)
 			    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 */
@@ -3623,7 +4029,7 @@ void term_out(Terminal *term)
 			    }
 			}
 			break;
-		      case 'Z':		/* CBT: BackTab for xterm */
+		      case 'Z':		/* CBT */
 			compatibility(OTHER);
 			{
 			    int i = def(term->esc_args[0], 1);
@@ -3672,6 +4078,7 @@ void term_out(Terminal *term)
 		      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
@@ -3680,18 +4087,20 @@ void term_out(Terminal *term)
 		      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 */
@@ -3699,12 +4108,13 @@ void term_out(Terminal *term)
 			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', '='):
@@ -3782,7 +4192,7 @@ void term_out(Terminal *term)
 			 * Well we should do a soft reset at this point ...
 			 */
 			if (!has_compat(VT420) && has_compat(VT100)) {
-			    if (!term->cfg.no_remote_resize) {
+			    if (!term->no_remote_resize) {
 				if (term->reset_132)
 				    request_resize(132, 24);
 				else
@@ -3866,7 +4276,7 @@ void term_out(Terminal *term)
 		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';
@@ -3910,7 +4320,7 @@ void term_out(Terminal *term)
 		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);
@@ -4017,7 +4427,8 @@ void term_out(Terminal *term)
 		     *     emulation.
 		     */
 		    term->vt52_mode = FALSE;
-		    term->blink_is_real = term->cfg.blinktext;
+		    term->blink_is_real = term->blinktext;
+		    term_schedule_tblink(term);
 		    break;
 #if 0
 		  case '^':
@@ -4139,22 +4550,14 @@ void term_out(Terminal *term)
 		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
@@ -4168,7 +4571,8 @@ void term_out(Terminal *term)
     }
 
     term_print_flush(term);
-    logflush(term->logctx);
+    if (term->logflush)
+	logflush(term->logctx);
 }
 
 /*
@@ -4201,8 +4605,11 @@ static int term_bidi_cache_hit(Terminal *term, int line,
 }
 
 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;
@@ -4217,20 +4624,141 @@ static void term_bidi_cache_store(Terminal *term, int line, termchar *lbefore,
 		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].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(width, termchar);
+    term->pre_bidi_cache[line].chars = snewn(size, termchar);
     term->post_bidi_cache[line].width = width;
-    term->post_bidi_cache[line].chars = snewn(width, termchar);
+    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->bidi || !term->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->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 =
+		    (unsigned int)uc;
+		term->wcFrom[it].index = it;
+	    }
+
+	    if(!term->bidi)
+		do_bidi(term->wcFrom, term->cols);
+
+	    /* this is saved iff done from inside the shaping */
+	    if(!term->bidi && term->arabicshaping)
+		for(it=0; it<term->cols; it++)
+		    term->wcTo[it] = term->wcFrom[it];
+
+	    if(!term->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, scr_y, ldata->chars,
+				  term->ltemp, term->wcTo,
+                                  term->cols, ldata->size);
+
+	    lchars = term->ltemp;
+	} else {
+	    lchars = term->post_bidi_cache[scr_y].chars;
+	}
+    } else {
+	lchars = NULL;
+    }
 
-    memcpy(term->pre_bidi_cache[line].chars, lbefore, width * TSIZE);
-    memcpy(term->post_bidi_cache[line].chars, lafter, width * TSIZE);
+    return lchars;
 }
 
 /*
@@ -4239,44 +4767,34 @@ static void term_bidi_cache_store(Terminal *term, int line, termchar *lbefore,
  */
 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);
 
     /* Depends on:
      * 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
+     * blinkpc, blink_is_real, tblinker, 
+     * curs.y, curs.x, cblinker, 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->blink_cur)
 		cursor = TATTR_ACTCURS;
 	    else
 		cursor = 0;
@@ -4289,17 +4807,28 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
     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);
     }
 
@@ -4343,114 +4872,50 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 	termchar *lchars;
 	int dirty_line, dirty_run, selected;
 	unsigned long attr = 0, cset = 0;
-	int updated_line = 0;
 	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].chars;
-	    }
-	} 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)
+            if (!term->ansi_colour)
                 tattr = (tattr & ~(ATTR_FGMASK | ATTR_BGMASK)) | 
                 ATTR_DEFFG | ATTR_DEFBG;
 
+	    if (!term->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];
@@ -4492,34 +4957,92 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 	     */
 	    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;
 	    }
 
-	    if ((term->disptext[i]->chars[j].attr ^ tattr) & ATTR_WIDE)
-		dirty_line = TRUE;
+	    /* FULL-TERMCHAR */
+	    newline[j].attr = tattr;
+	    newline[j].chr = tchar;
+	    /* Combining characters are still read from lchars */
+	    newline[j].cc_next = 0;
+	}
 
-	    break_run = ((tattr ^ attr) & term->attr_mask) != 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;
+
+	    break_run = ((tattr ^ attr) & term->attr_mask) != 0;
+
+#ifdef USES_VTLINE_HACK
 	    /* Special hack for VT100 Linedraw glyphs */
-	    if (tchar >= 0x23BA && tchar <= 0x23BD)
+	    if ((tchar >= 0x23BA && tchar <= 0x23BD) ||
+                (j > 0 && (newline[j-1].chr >= 0x23BA &&
+                           newline[j-1].chr <= 0x23BD)))
 		break_run = TRUE;
+#endif
 
 	    /*
 	     * Separate out sequences of characters that have the
@@ -4537,7 +5060,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 
 	    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;
@@ -4545,8 +5068,11 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 
 	    if (break_run) {
 		if ((dirty_run || last_run_dirty) && ccount > 0) {
-		    do_text(ctx, start, i, ch, ccount, attr, ldata->lattr);
-		    updated_line = 1;
+		    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);
 		}
 		start = j;
 		ccount = 0;
@@ -4564,10 +5090,17 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 		dirty_run = TRUE;
 	    }
 
-	    if (ccount >= chlen) {
+	    if (ccount+2 > chlen) {
 		chlen = ccount + 256;
 		ch = sresize(ch, chlen, wchar_t);
 	    }
+
+#ifdef PLATFORM_IS_UTF16
+	    if (tchar > 0x10000 && tchar < 0x110000) {
+		ch[ccount++] = (wchar_t) HIGH_SURROGATE_OF(tchar);
+		ch[ccount++] = (wchar_t) LOW_SURROGATE_OF(tchar);
+	    } else
+#endif /* PLATFORM_IS_UTF16 */
 	    ch[ccount++] = (wchar_t) tchar;
 
 	    if (d->cc_next) {
@@ -4591,10 +5124,17 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 			break;
 		    }
 
-		    if (ccount >= chlen) {
+		    if (ccount+2 > chlen) {
 			chlen = ccount + 256;
 			ch = sresize(ch, chlen, wchar_t);
 		    }
+
+#ifdef PLATFORM_IS_UTF16
+		    if (schar > 0x10000 && schar < 0x110000) {
+			ch[ccount++] = (wchar_t) HIGH_SURROGATE_OF(schar);
+			ch[ccount++] = (wchar_t) LOW_SURROGATE_OF(schar);
+		    } else
+#endif /* PLATFORM_IS_UTF16 */
 		    ch[ccount++] = (wchar_t) schar;
 		}
 
@@ -4605,6 +5145,8 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 		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. */
@@ -4624,94 +5166,21 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise)
 	    }
 	}
 	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;
-
-		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;
+	    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);
 	}
 
 	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)
@@ -4720,7 +5189,9 @@ 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);
 }
 
 /*
@@ -4738,18 +5209,17 @@ void term_paint(Terminal *term, Context ctx,
     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);
+    }
 }
 
 /*
@@ -4781,17 +5251,68 @@ void term_scroll(Terminal *term, int rel, int where)
     term_update(term);
 }
 
+/*
+ * Scroll the scrollback to centre it on the beginning or end of the
+ * current selection, if any.
+ */
+void term_scroll_to_selection(Terminal *term, int which_end)
+{
+    pos target;
+    int y;
+    int sbtop = -sblines(term);
+
+    if (term->selstate != SELECTED)
+	return;
+    if (which_end)
+	target = term->selend;
+    else
+	target = term->selstart;
+
+    y = target.y - term->rows/2;
+    if (y < sbtop)
+	y = sbtop;
+    else if (y > 0)
+	y = 0;
+    term_scroll(term, -1, y);
+}
+
+/*
+ * 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)) {
@@ -4814,7 +5335,8 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 	 * 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);
@@ -4844,7 +5366,7 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 	    sprintf(cbuf, "<U+%04x>", (ldata[top.x] & 0xFFFF));
 #else
 	    wchar_t cbuf[16], *p;
-	    int set, c;
+	    int c;
 	    int x = top.x;
 
 	    if (ldata->chars[x].chr == UCSWIDE) {
@@ -4854,10 +5376,11 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 
 	    while (1) {
 		int uc = ldata->chars[x].chr;
+                attr = ldata->chars[x].attr;
 
 		switch (uc & CSET_MASK) {
 		  case CSET_LINEDRW:
-		    if (!term->cfg.rawcnp) {
+		    if (!term->rawcnp) {
 			uc = term->ucsdata->unitab_xterm[uc & 0xFF];
 			break;
 		    }
@@ -4877,10 +5400,18 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 		    break;
 		}
 
-		set = (uc & CSET_MASK);
 		c = (uc & ~CSET_MASK);
-		cbuf[0] = uc;
-		cbuf[1] = 0;
+#ifdef PLATFORM_IS_UTF16
+		if (uc > 0x10000 && uc < 0x110000) {
+		    cbuf[0] = 0xD800 | ((uc - 0x10000) >> 10);
+		    cbuf[1] = 0xDC00 | ((uc - 0x10000) & 0x3FF);
+		    cbuf[2] = 0;
+		} else
+#endif
+		{
+		    cbuf[0] = uc;
+		    cbuf[1] = 0;
+		}
 
 		if (DIRECT_FONT(uc)) {
 		    if (c >= ' ' && c != 0x7F) {
@@ -4905,16 +5436,8 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 		}
 #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;
@@ -4925,10 +5448,8 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 	}
 	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;
@@ -4936,12 +5457,12 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel)
 	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)
@@ -5113,7 +5634,8 @@ static pos sel_spread_half(Terminal *term, pos p, int dir)
 		    else
 			break;
 		} else {
-		    if (ldata->lattr & LATTR_WRAPPED) {
+		    if (p.y+1 < term->rows && 
+                        (ldata->lattr & LATTR_WRAPPED)) {
 			termline *ldata2;
 			ldata2 = lineptr(p.y+1);
 			if (wordtype(term, UCSGET(ldata2->chars, 0))
@@ -5198,7 +5720,12 @@ void term_do_paste(Terminal *term)
         if (term->paste_buffer)
             sfree(term->paste_buffer);
         term->paste_pos = term->paste_hold = term->paste_len = 0;
-        term->paste_buffer = snewn(len, wchar_t);
+        term->paste_buffer = snewn(len + 12, wchar_t);
+
+        if (term->bracketed_paste) {
+            memcpy(term->paste_buffer, L"\033[200~", 6 * sizeof(wchar_t));
+            term->paste_len += 6;
+        }
 
         p = q = data;
         while (p < data + len) {
@@ -5222,6 +5749,12 @@ void term_do_paste(Terminal *term)
             q = p;
         }
 
+        if (term->bracketed_paste) {
+            memcpy(term->paste_buffer + term->paste_len,
+                   L"\033[201~", 6 * sizeof(wchar_t));
+            term->paste_len += 6;
+        }
+
         /* Assume a small paste will be OK in one go. */
         if (term->paste_len < 256) {
             if (term->ldisc)
@@ -5241,8 +5774,8 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
     pos selpoint;
     termline *ldata;
     int raw_mouse = (term->xterm_mouse &&
-		     !term->cfg.no_mouse_rep &&
-		     !(term->cfg.mouse_override && shift));
+		     !term->no_mouse_rep &&
+		     !(term->mouse_override && shift));
     int default_seltype;
 
     if (y < 0) {
@@ -5266,33 +5799,53 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
 	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];
+	char abuf[32];
+	int len = 0;
 
 	if (term->ldisc) {
 
 	    switch (braw) {
 	      case MBT_LEFT:
-		encstate = 0x20;	       /* left button down */
+		encstate = 0x00;	       /* left button down */
 		break;
 	      case MBT_MIDDLE:
-		encstate = 0x21;
+		encstate = 0x01;
 		break;
 	      case MBT_RIGHT:
-		encstate = 0x22;
+		encstate = 0x02;
 		break;
 	      case MBT_WHEEL_UP:
-		encstate = 0x60;
+		encstate = 0x40;
 		break;
 	      case MBT_WHEEL_DOWN:
-		encstate = 0x61;
+		encstate = 0x41;
 		break;
 	      default: break;	       /* placate gcc warning about enum use */
 	    }
@@ -5303,7 +5856,9 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
 		encstate += 0x20;
 		break;
 	      case MA_RELEASE:
-		encstate = 0x23;
+		/* If multiple extensions are enabled, the xterm 1006 is used, so it's okay to check for only that */
+		if (!term->xterm_extended_mouse)
+		    encstate = 0x03;
 		term->mouse_is_down = 0;
 		break;
 	      case MA_CLICK:
@@ -5317,11 +5872,18 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
 		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);
+	    r = y + 1;
+	    c = x + 1;
+
+	    /* Check the extensions in decreasing order of preference. Encoding the release event above assumes that 1006 comes first. */
+	    if (term->xterm_extended_mouse) {
+		len = sprintf(abuf, "\033[<%d;%d;%d%c", encstate, c, r, a == MA_RELEASE ? 'm' : 'M');
+	    } else if (term->urxvt_extended_mouse) {
+		len = sprintf(abuf, "\033[%d;%d;%dM", encstate + 32, c, r);
+	    } else if (c <= 223 && r <= 223) {
+		len = sprintf(abuf, "\033[M%c%c%c", encstate + 32, c + 32, r + 32);
+	    }
+	    ldisc_send(term->ldisc, abuf, len, 0);
 	}
 	return;
     }
@@ -5330,7 +5892,7 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
      * Set the selection type (rectangular or normal) at the start
      * of a selection attempt, from the state of Alt.
      */
-    if (!alt ^ !term->cfg.rect_select)
+    if (!alt ^ !term->rect_select)
 	default_seltype = RECTANGULAR;
     else
 	default_seltype = LEXICOGRAPHIC;
@@ -5440,447 +6002,50 @@ void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked,
 	request_paste(term->frontend);
     }
 
+    /*
+     * Since terminal output is suppressed during drag-selects, we
+     * should make sure to write any pending output if one has just
+     * finished.
+     */
+    if (term->selstate != DRAGGING)
+        term_out(term);
     term_update(term);
 }
 
-void term_key(Terminal *term, Key_Sym keysym, wchar_t *text, size_t tlen,
-	      unsigned int modifiers, unsigned int flags)
+int format_arrow_key(char *buf, Terminal *term, int xkey, int ctrl)
 {
-    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;
+    char *p = buf;
 
+    if (term->vt52_mode)
+	p += sprintf((char *) p, "\x1B%c", xkey);
+    else {
+	int app_flg = (term->app_cursor_keys && !term->no_applic_c);
+#if 0
 	/*
-	 * In VT400 mode, PFn always emits an escape sequence.  In
-	 * Linux and tilde modes, this only happens in app keypad mode.
+	 * RDB: VT100 & VT102 manuals both state the app cursor
+	 * keys only work if the app keypad is on.
+	 *
+	 * SGT: That may well be true, but xterm disagrees and so
+	 * does at least one application, so I've #if'ed this out
+	 * and the behaviour is back to PuTTY's original: app
+	 * cursor and app keypad are independently switchable
+	 * modes. If anyone complains about _this_ I'll have to
+	 * put in a configurable option.
 	 */
-	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' */
-    }
+	if (!term->app_keypad_keys)
+	    app_flg = 0;
+#endif
+	/* Useful mapping of Ctrl-arrows */
+	if (ctrl)
+	    app_flg = !app_flg;
 
-    /* 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' */
-	    }
+	if (app_flg)
+	    p += sprintf((char *) p, "\x1BO%c", xkey);
+	else
 	    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: xkey=0; 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: code = 0; 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: xkey = 0; 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);
-	}
-    }
+    return p - buf;
 }
 
 void term_nopaste(Terminal *term)
@@ -5943,6 +6108,14 @@ void term_deselect(Terminal *term)
 {
     deselect(term);
     term_update(term);
+
+    /*
+     * Since terminal output is suppressed during drag-selects, we
+     * should make sure to write any pending output if one has just
+     * finished.
+     */
+    if (term->selstate != DRAGGING)
+        term_out(term);
 }
 
 int term_ldisc(Terminal *term, int option)
@@ -5960,8 +6133,14 @@ int term_data(Terminal *term, int is_stderr, const char *data, int len)
 
     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;
     }
 
@@ -5972,13 +6151,13 @@ int term_data(Terminal *term, int is_stderr, const char *data, int len)
      * 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.
      *
@@ -5987,7 +6166,172 @@ int term_data(Terminal *term, int is_stderr, const char *data, int len)
     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->bksp_is_delete ? "^?" : "^H";
+    }
+    /* FIXME: perhaps we should set ONLCR based on lfhascr as well? */
+    /* FIXME: or ECHO and friends based on local echo state? */
+    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++)
+                prompt_set_result(p->prompts[i], "");
+	}
+    }
+
+    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);
+                prompt_ensure_result_size(pr, s->pos + 1);
+		pr->result[s->pos] = '\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)) {
+                    prompt_ensure_result_size(pr, s->pos + 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 */
+    }
+}