src/screen.C

   1 /*---------------------------------------------------------------------------*
   2  * File:        screen.C
   3  *---------------------------------------------------------------------------*
   4  *
   5  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
   6  * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *--------------------------------------------------------------------------*/
  22
  23 /*
  24  * This file handles _all_ screen updates and selections
  25  */
  26
  27 #include "../config.h"          /* NECESSARY */
  28 #include "rxvt.h"               /* NECESSARY */
  29 #include "rxvtperl.h"           /* NECESSARY */
  30
  31 #include <inttypes.h>
  32
  33 #include "salloc.C" // HACK, should be a seperate compile!
  34
  35 static inline void fill_text (text_t *start, text_t value, int len)
  36 {
  37   while (len--)
  38     *start++ = value;
  39 }
  40
  41 /* ------------------------------------------------------------------------- */
  42 #define PROP_SIZE               256*1024
  43 #define PASTE_SIZE              32768
  44 #define TABSIZE                 8       /* default tab size */
  45
  46 /* ------------------------------------------------------------------------- *
  47  *             GENERAL SCREEN AND SELECTION UPDATE ROUTINES                  *
  48  * ------------------------------------------------------------------------- */
  49 #define ZERO_SCROLLBACK()                                              \
  50     if (option (Opt_scrollTtyOutput))                                  \
  51         view_start = 0
  52 #define CLEAR_SELECTION()                                              \
  53     selection.beg.row = selection.beg.col                              \
  54         = selection.end.row = selection.end.col = 0
  55 #define CLEAR_ALL_SELECTION()                                          \
  56     selection.beg.row = selection.beg.col                              \
  57         = selection.mark.row = selection.mark.col                      \
  58         = selection.end.row = selection.end.col = 0
  59
  60 #define ROW_AND_COL_IS_AFTER(A, B, C, D)                               \
  61     (((A) > (C)) || (((A) == (C)) && ((B) > (D))))
  62 #define ROW_AND_COL_IS_BEFORE(A, B, C, D)                              \
  63     (((A) < (C)) || (((A) == (C)) && ((B) < (D))))
  64 #define ROW_AND_COL_IN_ROW_AFTER(A, B, C, D)                           \
  65     (((A) == (C)) && ((B) > (D)))
  66 #define ROW_AND_COL_IN_ROW_AT_OR_AFTER(A, B, C, D)                     \
  67     (((A) == (C)) && ((B) >= (D)))
  68 #define ROW_AND_COL_IN_ROW_BEFORE(A, B, C, D)                          \
  69     (((A) == (C)) && ((B) < (D)))
  70 #define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D)                    \
  71     (((A) == (C)) && ((B) <= (D)))
  72
  73 /* these must be row_col_t */
  74 #define ROWCOL_IS_AFTER(X, Y)                                          \
  75     ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)
  76 #define ROWCOL_IS_BEFORE(X, Y)                                         \
  77     ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
  78 #define ROWCOL_IN_ROW_AFTER(X, Y)                                      \
  79     ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)
  80 #define ROWCOL_IN_ROW_BEFORE(X, Y)                                     \
  81     ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
  82 #define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y)                                \
  83     ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)
  84 #define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y)                               \
  85     ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
  86
  87 /*
  88  * CLEAR_ROWS : clear <num> rows starting from row <row>
  89  * CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
  90  * ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour
  91  */
  92 #define drawBuffer      vt
  93
  94 #define CLEAR_ROWS(row, num)                                           \
  95     if (mapped)                                                \
  96         XClearArea (dpy, drawBuffer, 0,                   \
  97                     Row2Pixel (row), (unsigned int)width,      \
  98                     (unsigned int)Height2Pixel (num), False)
  99
 100 #define CLEAR_CHARS(x, y, num)                                         \
 101     if (mapped)                                                \
 102         XClearArea (dpy, drawBuffer, x, y,                \
 103                     (unsigned int)Width2Pixel (num),                   \
 104                     (unsigned int)Height2Pixel (1), False)
 105
 106 #define ERASE_ROWS(row, num)                                           \
 107     XFillRectangle (dpy, drawBuffer, gc,          \
 108                     0, Row2Pixel (row),                                \
 109                     (unsigned int)width,                       \
 110                     (unsigned int)Height2Pixel (num))
 111
 112 /* ------------------------------------------------------------------------- *
 113  *                        SCREEN `COMMON' ROUTINES                           *
 114  * ------------------------------------------------------------------------- */
 115
 116 /* Fill part/all of a line with blanks. */
 117 void
 118 rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
 119 {
 120   if (!l.t)
 121     {
 122       lalloc (l);
 123       col = 0;
 124       width = ncol;
 125     }
 126
 127   l.touch ();
 128
 129   efs &= ~RS_baseattrMask; // remove italic etc. fontstyles
 130   efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
 131
 132   text_t *et = l.t + col;
 133   rend_t *er = l.r + col;
 134
 135   while (width--)
 136     {
 137       *et++ = ' ';
 138       *er++ = efs;
 139     }
 140 }
 141
 142 /* ------------------------------------------------------------------------- */
 143 /* Fill a full line with blanks - make sure it is allocated first */
 144 void
 145 rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs) const NOTHROW
 146 {
 147   scr_blank_line (l, 0, ncol, efs);
 148
 149   l.l = 0;
 150   l.f = 0;
 151 }
 152
 153 /* ------------------------------------------------------------------------- *
 154  *                          SCREEN INITIALISATION                            *
 155  * ------------------------------------------------------------------------- */
 156
 157 void
 158 rxvt_term::scr_reset ()
 159 {
 160 #if ENABLE_OVERLAY
 161   scr_overlay_off ();
 162 #endif
 163
 164   rvideo_mode = false;
 165   view_start = 0;
 166   num_scr = 0;
 167
 168   if (ncol == 0)
 169     ncol = 80;
 170
 171   if (nrow == 0)
 172     nrow = 24;
 173
 174   if (ncol == prev_ncol && nrow == prev_nrow)
 175     return;
 176
 177   if (current_screen != PRIMARY)
 178     scr_swap_screen ();
 179
 180   // we need at least two lines for wrapping to work correctly
 181   while (nrow + saveLines < 2)
 182     {
 183       //TODO//FIXME
 184       saveLines++;
 185       prev_nrow--;
 186       top_row--;
 187     }
 188
 189   want_refresh = 1;
 190
 191   int prev_total_rows = prev_nrow + saveLines;
 192   total_rows = nrow + saveLines;
 193
 194   screen.tscroll = 0;
 195   screen.bscroll = nrow - 1;
 196
 197   if (!row_buf)
 198     {
 199       /*
 200        * first time called so just malloc everything: don't rely on realloc
 201        */
 202       top_row    = 0;
 203       term_start = 0;
 204
 205       talloc = new rxvt_salloc (ncol * sizeof (text_t));
 206       ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
 207
 208       row_buf   = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
 209       drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
 210       swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
 211
 212       for (int row = nrow; row--; )
 213         {
 214           scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
 215           scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
 216           scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
 217         }
 218
 219       memset (charsets, 'B', sizeof (charsets));
 220       rstyle = DEFAULT_RSTYLE;
 221       screen.flags = Screen_DefaultFlags;
 222       screen.cur.row = screen.cur.col = 0;
 223       screen.charset = 0;
 224       current_screen = PRIMARY;
 225       scr_cursor (SAVE);
 226
 227 #if NSCREENS
 228       swap.flags = Screen_DefaultFlags;
 229       swap.cur.row = swap.cur.col = 0;
 230       swap.charset = 0;
 231       current_screen = SECONDARY;
 232       scr_cursor (SAVE);
 233       current_screen = PRIMARY;
 234 #endif
 235
 236       selection.text = NULL;
 237       selection.len = 0;
 238       selection.op = SELECTION_CLEAR;
 239       selection.screen = PRIMARY;
 240       selection.clicks = 0;
 241     }
 242   else
 243     {
 244       /*
 245        * add or delete rows as appropriate
 246        */
 247
 248       rxvt_salloc *old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t));
 249       rxvt_salloc *old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
 250
 251 #if 0
 252       if (nrow < prev_nrow)
 253         {
 254           for (int row = nrow; row < prev_nrow; row++)
 255             {
 256               lfree (swap_buf [row]);
 257               lfree (drawn_buf[row]);
 258             }
 259         }
 260 #endif
 261
 262       drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
 263       swap_buf  = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
 264
 265       for (int row = min (nrow, prev_nrow); row--; )
 266         {
 267           lresize (drawn_buf[row]);
 268           lresize (swap_buf [row]);
 269         }
 270
 271       for (int row = prev_nrow; row < nrow; row++)
 272         {
 273           swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
 274           drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
 275         }
 276
 277       line_t *old_buf = row_buf;
 278       row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
 279
 280       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
 281       int pend = MOD (term_start + top_row  , prev_total_rows);
 282       int q    = total_rows; // rewrapped row
 283
 284       if (top_row)
 285         {
 286           // Re-wrap lines. This is rather ugly, possibly because I am too dumb
 287           // to come up with a lean and mean algorithm.
 288
 289           row_col_t ocur = screen.cur;
 290           ocur.row = MOD (term_start + ocur.row, prev_total_rows);
 291
 292           do
 293             {
 294               p = MOD (p - 1, prev_total_rows);
 295 #ifdef DEBUG_STRICT
 296               assert (old_buf [MOD (p, prev_total_rows)].t);
 297 #endif
 298               int plines = 1;
 299               int llen = old_buf [MOD (p, prev_total_rows)].l;
 300
 301               while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
 302                 {
 303                   p = MOD (p - 1, prev_total_rows);
 304
 305                   plines++;
 306                   llen += prev_ncol;
 307                 }
 308
 309               int qlines = max (0, (llen - 1) / ncol) + 1;
 310
 311               // drop partial lines completely
 312               if (q < qlines)
 313                 break;
 314
 315               q -= qlines;
 316
 317               int lofs = 0;
 318               line_t *qline;
 319
 320               // re-assemble the full line by destination lines
 321               for (int qrow = q; qlines--; qrow++)
 322                 {
 323                   qline = row_buf + qrow;
 324                   lalloc (*qline);
 325                   qline->l = ncol;
 326                   qline->is_longer (1);
 327
 328                   int qcol = 0;
 329
 330                   // see below for cursor adjustment rationale
 331                   if (p == ocur.row)
 332                     screen.cur.row = q - (total_rows - nrow);
 333
 334                   // fill a single destination line
 335                   while (lofs < llen && qcol < ncol)
 336                     {
 337                       int prow = lofs / prev_ncol;
 338                       int pcol = lofs % prev_ncol;
 339
 340                       prow = MOD (p + prow, prev_total_rows);
 341
 342                       // we only adjust the cursor _row_ and put it into
 343                       // the topmost line of "long line" it was in, as
 344                       // this seems to upset applications/shells/readline
 345                       // least.
 346                       if (prow == ocur.row)
 347                         screen.cur.row = q - (total_rows - nrow);
 348
 349                       line_t &pline = old_buf [prow];
 350
 351                       int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
 352
 353                       memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
 354                       memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
 355
 356                       lofs += len;
 357                       qcol += len;
 358                     }
 359                 }
 360
 361               qline->l = llen ? MOD (llen - 1, ncol) + 1 : 0;
 362               qline->is_longer (0);
 363               scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
 364             }
 365           while (p != pend && q > 0);
 366
 367           term_start = total_rows - nrow;
 368           top_row = q - term_start;
 369
 370           // make sure all terminal lines exist
 371           while (top_row > 0)
 372             scr_blank_screen_mem (ROW (--top_row), DEFAULT_RSTYLE);
 373         }
 374       else
 375         {
 376           // if no scrollback exists (yet), wing, instead of wrap
 377
 378           for (int row = min (nrow, prev_nrow); row--; )
 379             {
 380               line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];
 381               line_t &qline = row_buf [row];
 382
 383               qline = pline;
 384               lresize (qline);
 385             }
 386
 387           for (int row = prev_nrow; row < nrow; row++)
 388             {
 389               row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
 390             }
 391
 392           term_start = 0;
 393         }
 394
 395       free (old_buf);
 396       delete old_ta;
 397       delete old_ra;
 398
 399       clamp_it (screen.cur.row, 0, nrow - 1);
 400       clamp_it (screen.cur.col, 0, ncol - 1);
 401
 402       free (tabs);
 403     }
 404
 405   CLEAR_ALL_SELECTION ();
 406
 407   prev_nrow = nrow;
 408   prev_ncol = ncol;
 409
 410   tabs = (char *)rxvt_malloc (ncol);
 411
 412   for (int col = ncol; --col; )
 413     tabs [col] = col % TABSIZE == 0;
 414
 415   if (current_screen != PRIMARY)
 416     scr_swap_screen ();
 417
 418   tt_winch ();
 419
 420   HOOK_INVOKE ((this, HOOK_RESET, DT_END));
 421 }
 422
 423 /* ------------------------------------------------------------------------- */
 424 /*
 425  * Free everything.  That way malloc debugging can find leakage.
 426  */
 427 void
 428 rxvt_term::scr_release () NOTHROW
 429 {
 430   if (row_buf)
 431     {
 432       delete talloc; talloc = 0;
 433       delete ralloc; ralloc = 0;
 434
 435       free (row_buf);
 436       free (swap_buf);
 437       free (drawn_buf);
 438       free (tabs);
 439
 440       row_buf = 0; // signal that we freed all the arrays
 441     }
 442 }
 443
 444 /* ------------------------------------------------------------------------- */
 445 /*
 446  * Hard reset
 447  */
 448 void
 449 rxvt_term::scr_poweron ()
 450 {
 451   scr_release ();
 452   prev_nrow = prev_ncol = 0;
 453   scr_reset ();
 454
 455   scr_clear (true);
 456   scr_refresh ();
 457 }
 458
 459 /* ------------------------------------------------------------------------- *
 460  *                         PROCESS SCREEN COMMANDS                           *
 461  * ------------------------------------------------------------------------- */
 462 /*
 463  * Save and Restore cursor
 464  * XTERM_SEQ: Save cursor   : ESC 7
 465  * XTERM_SEQ: Restore cursor: ESC 8
 466  */
 467 void
 468 rxvt_term::scr_cursor (cursor_mode mode) NOTHROW
 469 {
 470   screen_t *s;
 471
 472 #if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
 473   if (current_screen == SECONDARY)
 474     s = &swap;
 475   else
 476 #endif
 477     s = &screen;
 478
 479   switch (mode)
 480     {
 481       case SAVE:
 482         s->s_cur.row = screen.cur.row;
 483         s->s_cur.col = screen.cur.col;
 484         s->s_rstyle = rstyle;
 485         s->s_charset = screen.charset;
 486         s->s_charset_char = charsets[screen.charset];
 487         break;
 488
 489       case RESTORE:
 490         want_refresh = 1;
 491         screen.cur.row = s->s_cur.row;
 492         screen.cur.col = s->s_cur.col;
 493         screen.flags &= ~Screen_WrapNext;
 494         rstyle = s->s_rstyle;
 495         screen.charset = s->s_charset;
 496         charsets[screen.charset] = s->s_charset_char;
 497         set_font_style ();
 498         break;
 499     }
 500
 501   /* boundary check in case screen size changed between SAVE and RESTORE */
 502   min_it (s->cur.row, nrow - 1);
 503   min_it (s->cur.col, ncol - 1);
 504 #ifdef DEBUG_STRICT
 505   assert (s->cur.row >= 0);
 506   assert (s->cur.col >= 0);
 507 #endif
 508 }
 509
 510 void
 511 rxvt_term::scr_swap_screen ()
 512 {
 513   if (!option (Opt_secondaryScreen))
 514     return;
 515
 516   for (int i = prev_nrow; i--; )
 517     ::swap (ROW(i), swap_buf [i]);
 518
 519   ::swap (screen.cur, swap.cur);
 520
 521   screen.cur.row = clamp (screen.cur.row, 0, prev_nrow - 1);
 522   screen.cur.col = clamp (screen.cur.col, 0, prev_ncol - 1);
 523 }
 524
 525 /* ------------------------------------------------------------------------- */
 526 /*
 527  * Swap between primary and secondary screens
 528  * XTERM_SEQ: Primary screen  : ESC [ ? 4 7 h
 529  * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
 530  */
 531 void
 532 rxvt_term::scr_change_screen (int scrn)
 533 {
 534   if (scrn == current_screen)
 535     return;
 536
 537   want_refresh = 1;
 538   view_start = 0;
 539
 540   selection_check (2);        /* check for boundary cross */
 541
 542   int i = current_screen; current_screen = scrn; scrn = i;
 543
 544 #if NSCREENS
 545   if (option (Opt_secondaryScreen))
 546     {
 547       num_scr = 0;
 548
 549       scr_swap_screen ();
 550
 551       ::swap (screen.charset, swap.charset);
 552       ::swap (screen.flags,   swap.flags);
 553       screen.flags |= Screen_VisibleCursor;
 554       swap.flags   |= Screen_VisibleCursor;
 555     }
 556   else
 557 #endif
 558     if (option (Opt_secondaryScroll))
 559       scr_scroll_text (0, prev_nrow - 1, prev_nrow);
 560 }
 561
 562 // clear WrapNext indicator, solidifying position on next line
 563 void
 564 rxvt_term::scr_do_wrap () NOTHROW
 565 {
 566   if (!(screen.flags & Screen_WrapNext))
 567     return;
 568
 569   screen.flags &= ~Screen_WrapNext;
 570
 571   screen.cur.col = 0;
 572
 573   if (screen.cur.row == screen.bscroll)
 574     scr_scroll_text (screen.tscroll, screen.bscroll, 1);
 575   else if (screen.cur.row < nrow - 1)
 576     screen.cur.row++;
 577 }
 578
 579 /* ------------------------------------------------------------------------- */
 580 /*
 581  * Change the colour for following text
 582  */
 583 void
 584 rxvt_term::scr_color (unsigned int color, int fgbg) NOTHROW
 585 {
 586   if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
 587     color = fgbg;
 588
 589   if (fgbg == Color_fg)
 590     rstyle = SET_FGCOLOR (rstyle, color);
 591   else
 592     rstyle = SET_BGCOLOR (rstyle, color);
 593 }
 594
 595 /* ------------------------------------------------------------------------- */
 596 /*
 597  * Change the rendition style for following text
 598  */
 599 void
 600 rxvt_term::scr_rendition (int set, int style) NOTHROW
 601   {
 602     if (set)
 603       rstyle |= style;
 604     else if (style == ~RS_None)
 605       rstyle = DEFAULT_RSTYLE;
 606     else
 607       rstyle &= ~style;
 608   }
 609
 610 /* ------------------------------------------------------------------------- */
 611 /*
 612  * Scroll text between <row1> and <row2> inclusive, by <count> lines
 613  * count positive ==> scroll up
 614  * count negative ==> scroll down
 615  */
 616 int
 617 rxvt_term::scr_scroll_text (int row1, int row2, int count) NOTHROW
 618 {
 619   if (count == 0 || (row1 > row2))
 620     return 0;
 621
 622   want_refresh = 1;
 623   num_scr += count;
 624
 625   if (count > 0
 626       && row1 == 0
 627       && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
 628     {
 629       top_row = max (top_row - count, -saveLines);
 630
 631       // scroll everything up 'count' lines
 632       term_start = (term_start + count) % total_rows;
 633
 634       // sever bottommost line
 635       {
 636         line_t &l = ROW(row2 - count);
 637         l.is_longer (0);
 638         l.touch ();
 639       }
 640
 641       // erase newly scrolled-in lines
 642       for (int i = count; i--; )
 643         {
 644           line_t &l = ROW(nrow - 1 - i);
 645
 646           // optimize if already cleared, can be significant on slow machines
 647           // could be rolled into scr_blank_screen_mem
 648           if (l.r && l.l < ncol - 1 && !((l.r[l.l + 1] ^ rstyle) & (RS_fgMask | RS_bgMask)))
 649             {
 650               scr_blank_line (l, 0, l.l, rstyle);
 651               l.l = 0;
 652               l.f = 0;
 653             }
 654           else
 655             scr_blank_screen_mem (l, rstyle);
 656         }
 657
 658       // now copy lines below the scroll region bottom to the
 659       // bottom of the screen again, so they look as if they
 660       // hadn't moved.
 661       for (int i = nrow; --i > row2; )
 662         {
 663           line_t &l1 = ROW(i - count);
 664           line_t &l2 = ROW(i);
 665
 666           ::swap (l1, l2);
 667           l2.touch ();
 668         }
 669
 670       // move and/or clear selection, if any
 671       if (selection.op && current_screen == selection.screen)
 672         {
 673           selection.beg.row  -= count;
 674           selection.end.row  -= count;
 675           selection.mark.row -= count;
 676
 677           if (selection.beg.row < top_row
 678               || selection.end.row < top_row
 679               || selection.mark.row < top_row)
 680             {
 681               CLEAR_ALL_SELECTION ();
 682               selection.op = SELECTION_CLEAR;
 683             }
 684         }
 685
 686       // finally move the view window, if desired
 687       if (option (Opt_scrollWithBuffer)
 688           && view_start != 0
 689           && view_start != -saveLines)
 690         scr_page (UP, count);
 691
 692       if (SHOULD_INVOKE (HOOK_SCROLL_BACK))
 693         HOOK_INVOKE ((this, HOOK_SCROLL_BACK, DT_INT, count, DT_INT, top_row, DT_END));
 694     }
 695   else
 696     {
 697       if (selection.op && current_screen == selection.screen)
 698         {
 699           if ((selection.beg.row < row1 && selection.end.row > row1)
 700               || (selection.beg.row < row2 && selection.end.row > row2)
 701               || (selection.beg.row - count < row1 && selection.beg.row >= row1)
 702               || (selection.beg.row - count > row2 && selection.beg.row <= row2)
 703               || (selection.end.row - count < row1 && selection.end.row >= row1)
 704               || (selection.end.row - count > row2 && selection.end.row <= row2))
 705             {
 706               CLEAR_ALL_SELECTION ();
 707               selection.op = SELECTION_CLEAR;
 708             }
 709           else if (selection.end.row >= row1 && selection.end.row <= row2)
 710             {
 711               /* move selected region too */
 712               selection.beg.row  -= count;
 713               selection.end.row  -= count;
 714               selection.mark.row -= count;
 715
 716               selection_check (0);
 717             }
 718         }
 719
 720       // use a simple and robust scrolling algorithm, this
 721       // part of scr_scroll_text is not time-critical.
 722
 723       int rows = row2 - row1 + 1;
 724
 725       min_it (count, rows);
 726
 727       line_t *temp_buf = row_buf + total_rows;
 728
 729       for (int row = 0; row < rows; row++)
 730         {
 731           temp_buf [row] = ROW(row1 + (row + count + rows) % rows);
 732
 733           if (!IN_RANGE_EXC (row + count, 0, rows))
 734             scr_blank_screen_mem (temp_buf [row], rstyle);
 735         }
 736
 737       for (int row = 0; row < rows; row++)
 738         ROW(row1 + row) = temp_buf [row];
 739     }
 740
 741   return count;
 742 }
 743
 744 /* ------------------------------------------------------------------------- */
 745 /*
 746  * Add text given in <str> of length <len> to screen struct
 747  */
 748 void
 749 rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW
 750 {
 751   if (len <= 0)               /* sanity */
 752     return;
 753
 754   unsigned char checksel;
 755   unicode_t c;
 756   int ncol = this->ncol;
 757   const wchar_t *strend = str + len;
 758
 759   want_refresh = 1;
 760   ZERO_SCROLLBACK ();
 761
 762   if (minlines > 0)
 763     {
 764       minlines += screen.cur.row - screen.bscroll;
 765       min_it (minlines, screen.cur.row - top_row);
 766
 767       if (minlines > 0
 768           && screen.tscroll == 0
 769           && screen.bscroll == nrow - 1)
 770         {
 771           /* _at least_ this many lines need to be scrolled */
 772           scr_scroll_text (screen.tscroll, screen.bscroll, minlines);
 773           screen.cur.row -= minlines;
 774         }
 775     }
 776
 777 #ifdef DEBUG_STRICT
 778   assert (screen.cur.col < ncol);
 779   assert (screen.cur.row < nrow
 780           && screen.cur.row >= top_row);
 781 #endif
 782   int row = screen.cur.row;
 783
 784   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
 785
 786   line_t *line = &ROW(row);
 787
 788   while (str < strend)
 789     {
 790       c = (unicode_t)*str++; // convert to rxvt-unicodes representation
 791
 792       if (c < 0x20)
 793         if (c == C0_LF)
 794           {
 795             max_it (line->l, screen.cur.col);
 796
 797             screen.flags &= ~Screen_WrapNext;
 798
 799             if (screen.cur.row == screen.bscroll)
 800               scr_scroll_text (screen.tscroll, screen.bscroll, 1);
 801             else if (screen.cur.row < (nrow - 1))
 802               row = ++screen.cur.row;
 803
 804             line = &ROW(row);  /* _must_ refresh */
 805             continue;
 806           }
 807         else if (c == C0_CR)
 808           {
 809             max_it (line->l, screen.cur.col);
 810
 811             screen.flags &= ~Screen_WrapNext;
 812             screen.cur.col = 0;
 813             continue;
 814           }
 815         else if (c == C0_HT)
 816           {
 817             scr_tab (1, true);
 818             continue;
 819           }
 820
 821       if (checksel            /* see if we're writing within selection */
 822           && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
 823           && ROWCOL_IS_BEFORE (screen.cur, selection.end))
 824         {
 825           checksel = 0;
 826           /*
 827            * If we wrote anywhere in the selected area, kill the selection
 828            * XXX: should we kill the mark too?  Possibly, but maybe that
 829            *      should be a similar check.
 830            */
 831           CLEAR_SELECTION ();
 832         }
 833
 834       if (screen.flags & Screen_WrapNext)
 835         {
 836           scr_do_wrap ();
 837
 838           line->l = ncol;
 839           line->is_longer (1);
 840
 841           row = screen.cur.row;
 842           line = &ROW(row);   /* _must_ refresh */
 843         }
 844
 845       // some utf-8 decoders "decode" surrogate characters: let's fix this.
 846       if (IN_RANGE_INC (c, 0xd800, 0xdfff))
 847         c = 0xfffd;
 848
 849       // rely on wcwidth to tell us the character width, do wcwidth before
 850       // further replacements, as wcwidth might return -1 for the line
 851       // drawing characters below as they might be invalid in the current
 852       // locale.
 853       int width = WCWIDTH (c);
 854
 855       if (charsets [screen.charset] == '0') // DEC SPECIAL
 856         {
 857           // vt100 special graphics and line drawing
 858           // 5f-7e standard vt100
 859           // 40-5e rxvt extension for extra curses acs chars
 860           static uint16_t vt100_0[62] = { // 41 .. 7e
 861                     0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 41-47 hi mr. snowman!
 862                  0,      0,      0,      0,      0,      0,      0,      0, // 48-4f
 863                  0,      0,      0,      0,      0,      0,      0,      0, // 50-57
 864                  0,      0,      0,      0,      0,      0,      0, 0x0020, // 58-5f
 865             0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67
 866             0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, // 68-6f
 867             0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, // 70-77
 868             0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,         // 78-7e
 869           };
 870
 871           if (c >= 0x41 && c <= 0x7e && vt100_0[c - 0x41])
 872             {
 873               c = vt100_0[c - 0x41];
 874               width = 1; // vt100 line drawing characters are always single-width
 875             }
 876         }
 877
 878       if (screen.flags & Screen_Insert)
 879         scr_insdel_chars (width, INSERT);
 880
 881       if (width != 0)
 882         {
 883 #if !UNICODE_3
 884           // trim characters we can't store directly :(
 885           if (c >= 0x10000)
 886 # if ENABLE_COMBINING
 887             c = rxvt_composite.compose (c); // map to lower 16 bits
 888 # else
 889             c = 0xfffd;
 890 # endif
 891 #endif
 892
 893           // nuke the character at this position, if required
 894           if (line->t[screen.cur.col] == NOCHAR
 895               || (screen.cur.col < ncol - 1
 896                   && line->t[screen.cur.col + 1] == NOCHAR))
 897             {
 898               int col = screen.cur.col;
 899
 900               // find begin
 901               while (col > 0 && line->t[col] == NOCHAR)
 902                 col--;
 903
 904               rend_t rend = SET_FONT (line->r[col], FONTSET (line->r[col])->find_font (' '));
 905
 906               // found begin, nuke
 907               do {
 908                 line->t[col] = ' ';
 909                 line->r[col] = rend;
 910                 col++;
 911               } while (col < ncol && line->t[col] == NOCHAR);
 912             }
 913
 914           rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
 915
 916           // if the character doesn't fit into the remaining columns...
 917           if (screen.cur.col > ncol - width && ncol >= width)
 918             {
 919               // ...output spaces
 920               c = ' ';
 921               // and try the same character next loop iteration
 922               --str;
 923             }
 924
 925           line->touch ();
 926
 927           do
 928             {
 929               line->t[screen.cur.col] = c;
 930               line->r[screen.cur.col] = rend;
 931
 932               if (screen.cur.col < ncol - 1)
 933                 screen.cur.col++;
 934               else
 935                 {
 936                   line->l = ncol;
 937                   if (screen.flags & Screen_Autowrap)
 938                     screen.flags |= Screen_WrapNext;
 939                   break;
 940                 }
 941
 942               c = NOCHAR;
 943             }
 944           while (--width > 0);
 945
 946           // pad with spaces when overwriting wide character with smaller one
 947           if (!width)
 948             {
 949               line->touch ();
 950
 951               for (int c = screen.cur.col; c < ncol && line->t[c] == NOCHAR; c++)
 952                 {
 953                   line->t[c] = ' ';
 954                   line->r[c] = rend;
 955                 }
 956             }
 957         }
 958       else // width == 0
 959         {
 960 #if ENABLE_COMBINING
 961           // handle combining characters
 962           // we just tag the accent on the previous on-screen character.
 963           // this is arguably not correct, but also arguably not wrong.
 964           // we don't handle double-width characters nicely yet.
 965           line_t *linep;
 966           text_t *tp;
 967           rend_t *rp;
 968
 969           if (screen.cur.col > 0)
 970             {
 971               linep = line;
 972               tp = line->t + screen.cur.col - 1;
 973               rp = line->r + screen.cur.col - 1;
 974             }
 975           else if (screen.cur.row > 0
 976                    && ROW(screen.cur.row - 1).is_longer ())
 977             {
 978               linep = &ROW(screen.cur.row - 1);
 979               tp = line->t + ncol - 1;
 980               rp = line->r + ncol - 1;
 981             }
 982           else
 983             continue;
 984
 985           linep->touch ();
 986
 987           while (*tp == NOCHAR && tp > linep->t)
 988             tp--, rp--;
 989
 990           // first try to find a precomposed character
 991           unicode_t n = rxvt_compose (*tp, c);
 992           if (n == NOCHAR)
 993             n = rxvt_composite.compose (*tp, c);
 994
 995           *tp = n;
 996           *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
 997 #endif
 998         }
 999     }
1000
1001   max_it (line->l, screen.cur.col);
1002
1003 #ifdef DEBUG_STRICT
1004   assert (screen.cur.row >= 0);
1005 #endif
1006 }
1007
1008 /* ------------------------------------------------------------------------- */
1009 /*
1010  * Process Backspace.  Move back the cursor back a position, wrap if have to
1011  * XTERM_SEQ: CTRL-H
1012  */
1013 void
1014 rxvt_term::scr_backspace () NOTHROW
1015 {
1016   want_refresh = 1;
1017
1018   if (screen.cur.col == 0)
1019     {
1020       if (screen.cur.row > 0)
1021         {
1022 #ifdef TERMCAP_HAS_BW
1023           screen.cur.col = ncol - 1;
1024           screen.cur.row--;
1025           return;
1026 #endif
1027         }
1028     }
1029   else if (!(screen.flags & Screen_WrapNext))
1030     scr_gotorc (0, -1, RELATIVE);
1031
1032   screen.flags &= ~Screen_WrapNext;
1033 }
1034
1035 /* ------------------------------------------------------------------------- */
1036 /*
1037  * Process Horizontal Tab
1038  * count: +ve = forward; -ve = backwards
1039  * XTERM_SEQ: CTRL-I
1040  */
1041 void
1042 rxvt_term::scr_tab (int count, bool ht) NOTHROW
1043 {
1044   int i, x;
1045
1046   want_refresh = 1;
1047   i = x = screen.cur.col;
1048
1049   if (count == 0)
1050     return;
1051   else if (count > 0)
1052     {
1053       line_t &l = ROW(screen.cur.row);
1054       rend_t base_rend = l.r[i];
1055       ht &= l.t[i] == ' ';
1056
1057       for (; ++i < ncol; )
1058         if (tabs[i])
1059           {
1060             x = i;
1061
1062             if (!--count)
1063               break;
1064           }
1065         else
1066           ht &= l.t[i] == ' '
1067                 && RS_SAME (l.r[i], base_rend);
1068
1069       if (count)
1070         x = ncol - 1;
1071
1072       // store horizontal tab commands as characters inside the text
1073       // buffer so they can be selected and pasted.
1074       if (ht && option (Opt_pastableTabs))
1075         {
1076           base_rend = SET_FONT (base_rend, 0);
1077
1078           l.touch (x);
1079
1080           i = screen.cur.col;
1081
1082           l.t[i] = '\t';
1083           l.r[i] = base_rend;
1084
1085           while (++i < x)
1086             {
1087               l.t[i] = NOCHAR;
1088               l.r[i] = base_rend;
1089             }
1090         }
1091     }
1092   else /* if (count < 0) */
1093     {
1094       for (; --i >= 0; )
1095         if (tabs[i])
1096           {
1097             x = i;
1098             if (!++count)
1099               break;
1100           }
1101
1102       if (count)
1103         x = 0;
1104     }
1105
1106   if (x != screen.cur.col)
1107     scr_gotorc (0, x, R_RELATIVE);
1108 }
1109
1110 /* ------------------------------------------------------------------------- */
1111 /*
1112  * Process DEC Back Index
1113  * XTERM_SEQ: ESC 6
1114  * Move cursor left in row.  If we're at the left boundary, shift everything
1115  * in that row right.  Clear left column.
1116  */
1117 #if !ENABLE_MINIMAL
1118 void
1119 rxvt_term::scr_backindex () NOTHROW
1120 {
1121   if (screen.cur.col > 0)
1122     scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
1123   else
1124     scr_insdel_chars (1, INSERT);
1125 }
1126 #endif
1127 /* ------------------------------------------------------------------------- */
1128 /*
1129  * Process DEC Forward Index
1130  * XTERM_SEQ: ESC 9
1131  * Move cursor right in row.  If we're at the right boundary, shift everything
1132  * in that row left.  Clear right column.
1133  */
1134 #if !ENABLE_MINIMAL
1135 void
1136 rxvt_term::scr_forwardindex () NOTHROW
1137 {
1138   if (screen.cur.col < ncol - 1)
1139     scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
1140   else
1141     {
1142       line_t &l = ROW(screen.cur.row);
1143
1144       l.touch ();
1145       l.is_longer (0);
1146
1147       scr_gotorc (0, 0, R_RELATIVE);
1148       scr_insdel_chars (1, DELETE);
1149       scr_gotorc (0, ncol - 1, R_RELATIVE);
1150     }
1151 }
1152 #endif
1153
1154 /* ------------------------------------------------------------------------- */
1155 /*
1156  * Goto Row/Column
1157  */
1158 void
1159 rxvt_term::scr_gotorc (int row, int col, int relative) NOTHROW
1160 {
1161   want_refresh = 1;
1162   ZERO_SCROLLBACK ();
1163
1164   screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
1165   clamp_it (screen.cur.col, 0, ncol - 1);
1166
1167   screen.flags &= ~Screen_WrapNext;
1168
1169   if (relative & R_RELATIVE)
1170     {
1171       if (row > 0)
1172         {
1173           if (screen.cur.row <= screen.bscroll
1174               && (screen.cur.row + row) > screen.bscroll)
1175             screen.cur.row = screen.bscroll;
1176           else
1177             screen.cur.row += row;
1178         }
1179       else if (row < 0)
1180         {
1181           if (screen.cur.row >= screen.tscroll
1182               && (screen.cur.row + row) < screen.tscroll)
1183             screen.cur.row = screen.tscroll;
1184           else
1185             screen.cur.row += row;
1186         }
1187     }
1188   else
1189     {
1190       if (screen.flags & Screen_Relative)
1191         {        /* relative origin mode */
1192           screen.cur.row = row + screen.tscroll;
1193           min_it (screen.cur.row, screen.bscroll);
1194         }
1195       else
1196         screen.cur.row = row;
1197     }
1198
1199   clamp_it (screen.cur.row, 0, nrow - 1);
1200 }
1201
1202 /* ------------------------------------------------------------------------- */
1203 /*
1204  * direction should be UP or DN
1205  */
1206 void
1207 rxvt_term::scr_index (enum page_dirn direction) NOTHROW
1208 {
1209   int dirn;
1210
1211   want_refresh = 1;
1212   ZERO_SCROLLBACK ();
1213
1214   dirn = ((direction == UP) ? 1 : -1);
1215
1216   screen.flags &= ~Screen_WrapNext;
1217
1218   if ((screen.cur.row == screen.bscroll && direction == UP)
1219       || (screen.cur.row == screen.tscroll && direction == DN))
1220     scr_scroll_text (screen.tscroll, screen.bscroll, dirn);
1221   else
1222     screen.cur.row += dirn;
1223
1224   clamp_it (screen.cur.row, 0, nrow - 1);
1225   selection_check (0);
1226 }
1227
1228 /* ------------------------------------------------------------------------- */
1229 /*
1230  * Erase part or whole of a line
1231  * XTERM_SEQ: Clear line to right: ESC [ 0 K
1232  * XTERM_SEQ: Clear line to left : ESC [ 1 K
1233  * XTERM_SEQ: Clear whole line   : ESC [ 2 K
1234  */
1235 void
1236 rxvt_term::scr_erase_line (int mode) NOTHROW
1237 {
1238   unsigned int col, num;
1239
1240   want_refresh = 1;
1241   ZERO_SCROLLBACK ();
1242
1243   selection_check (1);
1244
1245   line_t &line = ROW(screen.cur.row);
1246
1247   line.touch ();
1248   line.is_longer (0);
1249
1250   switch (mode)
1251     {
1252       case 0:                     /* erase to end of line */
1253         col = screen.cur.col;
1254         num = ncol - col;
1255         min_it (line.l, col);
1256         if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
1257             || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
1258           CLEAR_SELECTION ();
1259         break;
1260       case 1:                     /* erase to beginning of line */
1261         col = 0;
1262         num = screen.cur.col + 1;
1263         if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
1264             || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
1265           CLEAR_SELECTION ();
1266         break;
1267       case 2:                     /* erase whole line */
1268         col = 0;
1269         num = ncol;
1270         line.l = 0;
1271         if (selection.beg.row <= screen.cur.row
1272             && selection.end.row >= screen.cur.row)
1273           CLEAR_SELECTION ();
1274         break;
1275       default:
1276         return;
1277     }
1278
1279   scr_blank_line (line, col, num, rstyle);
1280 }
1281
1282 /* ------------------------------------------------------------------------- */
1283 /*
1284  * Erase part of whole of the screen
1285  * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
1286  * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
1287  * XTERM_SEQ: Clear whole screen        : ESC [ 2 J
1288  */
1289 void
1290 rxvt_term::scr_erase_screen (int mode) NOTHROW
1291 {
1292   int num;
1293   int32_t row;
1294   rend_t ren;
1295   XGCValues gcvalue;
1296
1297   want_refresh = 1;
1298   ZERO_SCROLLBACK ();
1299
1300   switch (mode)
1301     {
1302       case 0:                     /* erase to end of screen */
1303         selection_check (1);
1304         scr_erase_line (0);
1305         row = screen.cur.row + 1;    /* possible OOB */
1306         num = nrow - row;
1307         break;
1308       case 1:                     /* erase to beginning of screen */
1309         selection_check (3);
1310         scr_erase_line (1);
1311         row = 0;
1312         num = screen.cur.row;
1313         break;
1314       case 2:                     /* erase whole screen */
1315         selection_check (3);
1316         row = 0;
1317         num = nrow;
1318         break;
1319       default:
1320         return;
1321     }
1322
1323   if (selection.op && current_screen == selection.screen
1324       && ((selection.beg.row >= row && selection.beg.row <= row + num)
1325           || (selection.end.row >= row
1326               && selection.end.row <= row + num)))
1327     CLEAR_SELECTION ();
1328
1329   if (row >= nrow) /* Out Of Bounds */
1330     return;
1331
1332   min_it (num, nrow - row);
1333
1334   if (rstyle & (RS_RVid | RS_Uline))
1335     ren = (rend_t) ~RS_None;
1336   else if (GET_BASEBG (rstyle) == Color_bg)
1337     {
1338       ren = DEFAULT_RSTYLE;
1339       CLEAR_ROWS (row, num);
1340     }
1341   else
1342     {
1343       ren = rstyle & (RS_fgMask | RS_bgMask);
1344       gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
1345       XChangeGC (dpy, gc, GCForeground, &gcvalue);
1346       ERASE_ROWS (row, num);
1347       gcvalue.foreground = pix_colors[Color_fg];
1348       XChangeGC (dpy, gc, GCForeground, &gcvalue);
1349     }
1350
1351   for (; num--; row++)
1352     {
1353       scr_blank_screen_mem (ROW(row), rstyle);
1354       scr_blank_line (drawn_buf [row], 0, ncol, ren);
1355     }
1356 }
1357
1358 #if !ENABLE_MINIMAL
1359 void
1360 rxvt_term::scr_erase_savelines () NOTHROW
1361 {
1362   want_refresh = 1;
1363   ZERO_SCROLLBACK ();
1364
1365   top_row = 0;
1366 }
1367 #endif
1368
1369 /* ------------------------------------------------------------------------- */
1370 /*
1371  * Fill the screen with `E's
1372  * XTERM_SEQ: Screen Alignment Test: ESC # 8
1373  */
1374 void
1375 rxvt_term::scr_E () NOTHROW
1376 {
1377   rend_t fs;
1378
1379   want_refresh = 1;
1380   ZERO_SCROLLBACK ();
1381
1382   num_scr_allow = 0;
1383   selection_check (3);
1384
1385   fs = SET_FONT (rstyle, FONTSET (rstyle)->find_font ('E'));
1386   for (int row = nrow; row--; )
1387     {
1388       line_t &line = ROW(row);
1389
1390       fill_text (line.t, 'E', ncol);
1391       rend_t *r1 = line.r;
1392
1393       for (int j = ncol; j--; )
1394         *r1++ = fs;
1395
1396       line.is_longer (0);
1397       line.touch (ncol);
1398     }
1399 }
1400
1401 /* ------------------------------------------------------------------------- */
1402 /*
1403  * Insert/Delete <count> lines
1404  */
1405 void
1406 rxvt_term::scr_insdel_lines (int count, int insdel) NOTHROW
1407 {
1408   int end;
1409
1410   ZERO_SCROLLBACK ();
1411
1412   selection_check (1);
1413
1414   if (screen.cur.row > screen.bscroll)
1415     return;
1416
1417   end = screen.bscroll - screen.cur.row + 1;
1418   if (count > end)
1419     {
1420       if (insdel == DELETE)
1421         return;
1422       else if (insdel == INSERT)
1423         count = end;
1424     }
1425
1426   scr_do_wrap ();
1427
1428   scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count);
1429 }
1430
1431 /* ------------------------------------------------------------------------- */
1432 /*
1433  * Insert/Delete <count> characters from the current position
1434  */
1435 void
1436 rxvt_term::scr_insdel_chars (int count, int insdel) NOTHROW
1437 {
1438   int col, row;
1439   rend_t tr;
1440
1441   want_refresh = 1;
1442   ZERO_SCROLLBACK ();
1443
1444   if (count <= 0)
1445     return;
1446
1447   scr_do_wrap ();
1448
1449   selection_check (1);
1450   min_it (count, ncol - screen.cur.col);
1451
1452   row = screen.cur.row;
1453
1454   line_t *line = &ROW(row);
1455
1456   line->touch ();
1457   line->is_longer (0);
1458
1459   switch (insdel)
1460     {
1461       case INSERT:
1462         for (col = ncol - 1; (col - count) >= screen.cur.col; col--)
1463           {
1464             line->t[col] = line->t[col - count];
1465             line->r[col] = line->r[col - count];
1466           }
1467
1468         line->l = min (line->l + count, ncol);
1469
1470         if (selection.op && current_screen == selection.screen
1471             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1472           {
1473             if (selection.end.row != screen.cur.row
1474                 || (selection.end.col + count >= ncol))
1475               CLEAR_SELECTION ();
1476             else
1477               {              /* shift selection */
1478                 selection.beg.col  += count;
1479                 selection.mark.col += count; /* XXX: yes? */
1480                 selection.end.col  += count;
1481               }
1482           }
1483
1484         scr_blank_line (*line, screen.cur.col, count, rstyle);
1485         break;
1486
1487       case ERASE:
1488         screen.cur.col += count;     /* don't worry if > ncol */
1489         selection_check (1);
1490         screen.cur.col -= count;
1491
1492         line->l = max (line->l - count, 0);
1493         scr_blank_line (*line, screen.cur.col, count, rstyle);
1494         break;
1495
1496       case DELETE:
1497         tr = line->r[ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
1498
1499         for (col = screen.cur.col; (col + count) < ncol; col++)
1500           {
1501             line->t[col] = line->t[col + count];
1502             line->r[col] = line->r[col + count];
1503           }
1504
1505         line->l = max (line->l - count, 0);
1506         scr_blank_line (*line, ncol - count, count, tr);
1507
1508         if (selection.op && current_screen == selection.screen
1509             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1510           {
1511             if (selection.end.row != screen.cur.row
1512                 || (screen.cur.col >= selection.beg.col - count)
1513                 || selection.end.col >= ncol)
1514               CLEAR_SELECTION ();
1515             else
1516               {
1517                 /* shift selection */
1518                 selection.beg.col  -= count;
1519                 selection.mark.col -= count; /* XXX: yes? */
1520                 selection.end.col  -= count;
1521               }
1522           }
1523
1524         break;
1525     }
1526 }
1527
1528 /* ------------------------------------------------------------------------- */
1529 /*
1530  * Set the scrolling region
1531  * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
1532  */
1533 void
1534 rxvt_term::scr_scroll_region (int top, int bot) NOTHROW
1535 {
1536   max_it (top, 0);
1537   min_it (bot, nrow - 1);
1538
1539   if (top > bot)
1540     return;
1541
1542   screen.tscroll = top;
1543   screen.bscroll = bot;
1544   scr_gotorc (0, 0, 0);
1545 }
1546
1547 /* ------------------------------------------------------------------------- */
1548 /*
1549  * Make the cursor visible/invisible
1550  * XTERM_SEQ: Make cursor visible  : ESC [ ? 25 h
1551  * XTERM_SEQ: Make cursor invisible: ESC [ ? 25 l
1552  */
1553 void
1554 rxvt_term::scr_cursor_visible (int mode) NOTHROW
1555 {
1556   want_refresh = 1;
1557
1558   if (mode)
1559     screen.flags |= Screen_VisibleCursor;
1560   else
1561     screen.flags &= ~Screen_VisibleCursor;
1562 }
1563
1564 /* ------------------------------------------------------------------------- */
1565 /*
1566  * Set/unset automatic wrapping
1567  * XTERM_SEQ: Set Wraparound  : ESC [ ? 7 h
1568  * XTERM_SEQ: Unset Wraparound: ESC [ ? 7 l
1569  */
1570 void
1571 rxvt_term::scr_autowrap (int mode) NOTHROW
1572 {
1573   if (mode)
1574     screen.flags |= Screen_Autowrap;
1575   else
1576     screen.flags &= ~(Screen_Autowrap | Screen_WrapNext);
1577 }
1578
1579 /* ------------------------------------------------------------------------- */
1580 /*
1581  * Set/unset margin origin mode
1582  * Absolute mode: line numbers are counted relative to top margin of screen
1583  *      and the cursor can be moved outside the scrolling region.
1584  * Relative mode: line numbers are relative to top margin of scrolling region
1585  *      and the cursor cannot be moved outside.
1586  * XTERM_SEQ: Set Absolute: ESC [ ? 6 h
1587  * XTERM_SEQ: Set Relative: ESC [ ? 6 l
1588  */
1589 void
1590 rxvt_term::scr_relative_origin (int mode) NOTHROW
1591 {
1592   if (mode)
1593     screen.flags |= Screen_Relative;
1594   else
1595     screen.flags &= ~Screen_Relative;
1596
1597   scr_gotorc (0, 0, 0);
1598 }
1599
1600 /* ------------------------------------------------------------------------- */
1601 /*
1602  * Set insert/replace mode
1603  * XTERM_SEQ: Set Insert mode : ESC [ ? 4 h
1604  * XTERM_SEQ: Set Replace mode: ESC [ ? 4 l
1605  */
1606 void
1607 rxvt_term::scr_insert_mode (int mode) NOTHROW
1608 {
1609   if (mode)
1610     screen.flags |= Screen_Insert;
1611   else
1612     screen.flags &= ~Screen_Insert;
1613 }
1614
1615 /* ------------------------------------------------------------------------- */
1616 /*
1617  * Set/Unset tabs
1618  * XTERM_SEQ: Set tab at current column  : ESC H
1619  * XTERM_SEQ: Clear tab at current column: ESC [ 0 g
1620  * XTERM_SEQ: Clear all tabs             : ESC [ 3 g
1621  */
1622 void
1623 rxvt_term::scr_set_tab (int mode) NOTHROW
1624 {
1625   if (mode < 0)
1626     memset (tabs, 0, ncol);
1627   else if (screen.cur.col < ncol)
1628     tabs [screen.cur.col] = !!mode;
1629 }
1630
1631 /* ------------------------------------------------------------------------- */
1632 /*
1633  * Set reverse/normal video
1634  * XTERM_SEQ: Reverse video: ESC [ ? 5 h
1635  * XTERM_SEQ: Normal video : ESC [ ? 5 l
1636  */
1637 void
1638 rxvt_term::scr_rvideo_mode (bool on) NOTHROW
1639 {
1640   rvideo_mode = on;
1641
1642 #ifndef NO_BELL
1643   on ^= rvideo_bell;
1644 #endif
1645
1646   if (rvideo_state != on)
1647     {
1648       rvideo_state = on;
1649
1650       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
1651 #ifdef HAVE_BG_PIXMAP
1652       if (bgPixmap.pixmap == None)
1653 #endif
1654           XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
1655
1656       XGCValues gcvalue;
1657       gcvalue.foreground = pix_colors[Color_fg];
1658       gcvalue.background = pix_colors[Color_bg];
1659       XChangeGC (dpy, gc, GCBackground | GCForeground, &gcvalue);
1660
1661       scr_clear ();
1662       scr_touch (true);
1663     }
1664 }
1665
1666 /* ------------------------------------------------------------------------- */
1667 /*
1668  * Report current cursor position
1669  * XTERM_SEQ: Report position: ESC [ 6 n
1670  */
1671 void
1672 rxvt_term::scr_report_position () NOTHROW
1673 {
1674   tt_printf ("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
1675 }
1676 \f
1677 /* ------------------------------------------------------------------------- *
1678  *                                  FONTS                                    *
1679  * ------------------------------------------------------------------------- */
1680
1681 /*
1682  * Set font style
1683  */
1684 void
1685 rxvt_term::set_font_style () NOTHROW
1686 {
1687 #if 0
1688   switch (charsets [screen.charset])
1689     {
1690       case '0':                   /* DEC Special Character & Line Drawing Set */
1691         break;
1692       case 'A':                   /* United Kingdom (UK) */
1693         break;
1694       case 'B':                   /* United States (USASCII) */
1695         break;
1696       case '<':                   /* Multinational character set */
1697         break;
1698       case '5':                   /* Finnish character set */
1699         break;
1700       case 'C':                   /* Finnish character set */
1701         break;
1702       case 'K':                   /* German character set */
1703         break;
1704     }
1705 #endif
1706 }
1707
1708 /* ------------------------------------------------------------------------- */
1709 /*
1710  * Choose a font
1711  * XTERM_SEQ: Invoke G0 character set: CTRL-O
1712  * XTERM_SEQ: Invoke G1 character set: CTRL-N
1713  * XTERM_SEQ: Invoke G2 character set: ESC N
1714  * XTERM_SEQ: Invoke G3 character set: ESC O
1715  */
1716 void
1717 rxvt_term::scr_charset_choose (int set) NOTHROW
1718 {
1719   screen.charset = set;
1720   set_font_style ();
1721 }
1722
1723 /* ------------------------------------------------------------------------- */
1724 /*
1725  * Set a font
1726  * XTERM_SEQ: Set G0 character set: ESC ( <C>
1727  * XTERM_SEQ: Set G1 character set: ESC ) <C>
1728  * XTERM_SEQ: Set G2 character set: ESC * <C>
1729  * XTERM_SEQ: Set G3 character set: ESC + <C>
1730  * See set_font_style for possible values for <C>
1731  */
1732 void
1733 rxvt_term::scr_charset_set (int set, unsigned int ch) NOTHROW
1734 {
1735   charsets[set] = (unsigned char)ch;
1736   set_font_style ();
1737 }
1738
1739 \f
1740 /* ------------------------------------------------------------------------- *
1741  *                        MAJOR SCREEN MANIPULATION                          *
1742  * ------------------------------------------------------------------------- */
1743
1744 /*
1745  * refresh matching text.
1746  */
1747 bool
1748 rxvt_term::scr_refresh_rend (rend_t mask, rend_t value) NOTHROW
1749 {
1750   bool found = false;
1751
1752   for (int i = 0; i < nrow; i++)
1753     {
1754       rend_t *drp = drawn_buf[i].r;
1755
1756       for (int col = 0; col < ncol; col++, drp++)
1757         if ((*drp & mask) == value)
1758           {
1759             found = true;
1760             *drp = ~value;
1761           }
1762     }
1763
1764   return found;
1765 }
1766
1767 /*
1768  * Refresh an area
1769  */
1770 enum {
1771   PART_BEG = 0,
1772   PART_END,
1773   RC_COUNT
1774 };
1775
1776 void
1777 rxvt_term::scr_expose (int x, int y, int ewidth, int eheight, bool refresh) NOTHROW
1778 {
1779   int i;
1780   row_col_t rc[RC_COUNT];
1781
1782   if (!drawn_buf)  /* sanity check */
1783     return;
1784
1785 #ifndef NO_SLOW_LINK_SUPPORT
1786   if (refresh_type == FAST_REFRESH && !display->is_local)
1787     {
1788       y = 0;
1789       eheight = height;
1790     }
1791 #endif
1792
1793   /* round down */
1794   rc[PART_BEG].col = Pixel2Col (x);
1795   rc[PART_BEG].row = Pixel2Row (y);
1796   /* round up */
1797   rc[PART_END].col = Pixel2Width (x + ewidth  + fwidth  - 1);
1798   rc[PART_END].row = Pixel2Row   (y + eheight + fheight - 1);
1799
1800   /* sanity checks */
1801   for (i = PART_BEG; i < RC_COUNT; i++)
1802     {
1803       min_it (rc[i].col, ncol - 1);
1804       min_it (rc[i].row, nrow - 1);
1805     }
1806 // TODO: this line somehow causes segfault if scr_expose() is called just after resize
1807   for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
1808     fill_text (&drawn_buf[i].t[rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
1809
1810   num_scr_allow = 0;
1811
1812   if (refresh)
1813     scr_refresh ();
1814 }
1815
1816 /* ------------------------------------------------------------------------- */
1817 /*
1818  * Refresh the entire screen
1819  */
1820 void
1821 rxvt_term::scr_touch (bool refresh) NOTHROW
1822 {
1823   scr_expose (0, 0, width, height, refresh);
1824 }
1825
1826 /* ------------------------------------------------------------------------- */
1827 /*
1828  * Move the display so that the line represented by scrollbar value Y is at
1829  * the top of the screen
1830  */
1831 void
1832 rxvt_term::scr_move_to (int y, int len) NOTHROW
1833 {
1834   scr_changeview ((top_row - nrow) * (len - y) / len + (nrow - 1));
1835 }
1836
1837 /* ------------------------------------------------------------------------- */
1838 /*
1839  * Page the screen up/down nlines
1840  * direction should be UP or DN
1841  */
1842 bool
1843 rxvt_term::scr_page (enum page_dirn direction, int nlines) NOTHROW
1844 {
1845   int new_view_start =
1846     direction == UP ? view_start - nlines
1847                     : view_start + nlines;
1848
1849   return scr_changeview (new_view_start);
1850 }
1851
1852 bool
1853 rxvt_term::scr_changeview (int new_view_start) NOTHROW
1854 {
1855   clamp_it (new_view_start, top_row, 0);
1856
1857   if (new_view_start == view_start)
1858     return false;
1859
1860   num_scr += new_view_start - view_start;
1861   view_start = new_view_start;
1862   want_refresh = 1;
1863
1864   HOOK_INVOKE ((this, HOOK_VIEW_CHANGE, DT_INT, view_start, DT_END));
1865
1866   return true;
1867 }
1868
1869 #ifndef NO_BELL
1870 void
1871 rxvt_term::bell_cb (time_watcher &w)
1872 {
1873   rvideo_bell = false;
1874   scr_rvideo_mode (rvideo_mode);
1875 }
1876 #endif
1877
1878 /* ------------------------------------------------------------------------- */
1879 void
1880 rxvt_term::scr_bell () NOTHROW
1881 {
1882 #ifndef NO_BELL
1883
1884 # ifndef NO_MAPALERT
1885 #  ifdef MAPALERT_OPTION
1886   if (option (Opt_mapAlert))
1887 #  endif
1888     XMapWindow (dpy, parent[0]);
1889 # endif
1890
1891 # if ENABLE_FRILLS
1892   if (option (Opt_urgentOnBell))
1893     {
1894       if (XWMHints *h = XGetWMHints(dpy, parent[0]))
1895         {
1896           h->flags |= XUrgencyHint;
1897           XSetWMHints (dpy, parent[0], h);
1898         }
1899     }
1900 # endif
1901
1902   if (option (Opt_visualBell))
1903     {
1904       rvideo_bell = true;
1905       scr_rvideo_mode (rvideo_mode);
1906       display->flush ();
1907
1908       bell_ev.start (NOW + VISUAL_BELL_DURATION);
1909     }
1910   else
1911     XBell (dpy, 0);
1912 #endif
1913 }
1914
1915 /* ------------------------------------------------------------------------- */
1916 /* ARGSUSED */
1917 void
1918 rxvt_term::scr_printscreen (int fullhist) NOTHROW
1919 {
1920 #ifdef PRINTPIPE
1921   int nrows, row_start;
1922   FILE *fd;
1923
1924   if ((fd = popen_printer ()) == NULL)
1925     return;
1926
1927   if (fullhist)
1928     {
1929       nrows = nrow - top_row;
1930       row_start = top_row;
1931     }
1932   else
1933     {
1934       nrows = nrow;
1935       row_start = view_start;
1936     }
1937
1938   wctomb (0, 0);
1939
1940   for (int r1 = 0; r1 < nrows; r1++)
1941     {
1942       text_t *tp = ROW(r1).t;
1943       int len    = ROW(r1).l;
1944
1945       for (int i = len >= 0 ? len : ncol - 1; i--; ) //TODO//FIXME//LEN
1946         {
1947           char mb[MB_LEN_MAX];
1948           text_t t = *tp++;
1949           if (t == NOCHAR)
1950             continue;
1951
1952           len = wctomb (mb, t);
1953
1954           if (len <= 0)
1955             {
1956               mb[0] = ' ';
1957               len = 1;
1958             }
1959
1960           fwrite (mb, 1, len, fd);
1961         }
1962
1963       fputc ('\n', fd);
1964     }
1965
1966   pclose_printer (fd);
1967 #endif
1968 }
1969
1970 /* ------------------------------------------------------------------------- */
1971 /*
1972  * Refresh the screen
1973  * drawn_text/drawn_rend contain the screen information before the update.
1974  * screen.text/screen.rend contain what the screen will change to.
1975  */
1976 void
1977 rxvt_term::scr_refresh () NOTHROW
1978 {
1979   unsigned char have_bg,
1980                 showcursor; /* show the cursor                           */
1981   int16_t col, row,   /* column/row we're processing               */
1982           ocrow;      /* old cursor row                            */
1983   int i;              /* tmp                                       */
1984 #ifndef NO_CURSORCOLOR
1985   rend_t cc1;         /* store colours at cursor position (s)      */
1986 #endif
1987   rend_t *crp;        // cursor rendition pointer
1988   rend_t ccol1,  /* Cursor colour       */
1989          ccol2;  /* Cursor colour2      */
1990
1991   want_refresh = 0;        /* screen is current */
1992
1993   if (refresh_type == NO_REFRESH || !mapped)
1994     return;
1995
1996   /*
1997    * A: set up vars
1998    */
1999   have_bg = 0;
2000   refresh_count = 0;
2001
2002 #ifdef HAVE_BG_PIXMAP
2003   have_bg |= bgPixmap.pixmap != None;
2004 #endif
2005   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
2006
2007   /*
2008    * B: reverse any characters which are selected
2009    */
2010   scr_reverse_selection ();
2011
2012   /*
2013    * C: set the cursor character (s)
2014    */
2015   {
2016     unsigned char setoldcursor;
2017
2018     showcursor = (screen.flags & Screen_VisibleCursor);
2019 #ifdef CURSOR_BLINK
2020     if (hidden_cursor)
2021       showcursor = 0;
2022 #endif
2023
2024     if (showcursor)
2025       {
2026         int col = screen.cur.col;
2027
2028         while (col && ROW(screen.cur.row).t[col] == NOCHAR)
2029           col--;
2030
2031         crp = &ROW(screen.cur.row).r[col];
2032
2033 #ifndef NO_CURSORCOLOR
2034         cc1 = *crp & (RS_fgMask | RS_bgMask);
2035         if (ISSET_PIXCOLOR (Color_cursor))
2036           ccol1 = Color_cursor;
2037         else
2038 #endif
2039 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2040           ccol1 = fgcolor_of (rstyle);
2041 #else
2042           ccol1 = Color_fg;
2043 #endif
2044
2045 #ifndef NO_CURSORCOLOR
2046         if (ISSET_PIXCOLOR (Color_cursor2))
2047           ccol2 = Color_cursor2;
2048         else
2049 #endif
2050 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2051           ccol2 = bgcolor_of (rstyle);
2052 #else
2053           ccol2 = Color_bg;
2054 #endif
2055
2056         if (showcursor && focus)
2057           {
2058             if (option (Opt_cursorUnderline))
2059               *crp ^= RS_Uline;
2060             else
2061               {
2062                 *crp ^= RS_RVid;
2063                 *crp = SET_FGCOLOR (*crp, ccol1);
2064                 *crp = SET_BGCOLOR (*crp, ccol2);
2065               }
2066           }
2067       }
2068
2069     /* make sure no outline cursor is left around */
2070     setoldcursor = 0;
2071     if (ocrow != -1)
2072       {
2073         if (screen.cur.row - view_start != ocrow
2074             || screen.cur.col != oldcursor.col)
2075           {
2076             if (ocrow < nrow
2077                 && oldcursor.col < ncol)
2078               drawn_buf[ocrow].r[oldcursor.col] ^= (RS_RVid | RS_Uline);
2079
2080             if (focus || !showcursor)
2081               oldcursor.row = -1;
2082             else
2083               setoldcursor = 1;
2084           }
2085       }
2086     else if (!focus)
2087       setoldcursor = 1;
2088
2089     if (setoldcursor)
2090       {
2091         if (screen.cur.row - view_start >= nrow)
2092           oldcursor.row = -1;
2093         else
2094           {
2095             oldcursor.row = screen.cur.row - view_start;
2096             oldcursor.col = screen.cur.col;
2097           }
2098       }
2099   }
2100
2101   HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
2102 #if ENABLE_OVERLAY
2103   scr_swap_overlay ();
2104 #endif
2105
2106 #ifndef NO_SLOW_LINK_SUPPORT
2107   /*
2108    * D: CopyArea pass - very useful for slower links
2109    *    This has been deliberately kept simple.
2110    */
2111   if (!display->is_local
2112       && refresh_type == FAST_REFRESH && num_scr_allow && num_scr
2113       && abs (num_scr) < nrow && !have_bg)
2114     {
2115       int16_t nits;
2116       int i = num_scr;
2117       int j;
2118       int len, wlen;
2119       dLocal (int, num_scr);
2120
2121       j = nrow;
2122       wlen = len = -1;
2123       row = i > 0 ? 0 : j - 1;
2124
2125       for (; j-- >= 0; row += (i > 0 ? 1 : -1))
2126         {
2127           if (row + i >= 0 && row + i < nrow && row + i != ocrow)
2128             {
2129               line_t s  = ROW(view_start + row);
2130               line_t d  = drawn_buf[row];
2131               line_t d2 = drawn_buf[row + i];
2132
2133               for (nits = 0, col = ncol; col--; )
2134                 if (s.t[col] != d2.t[col] || s.r[col] != d2.r[col])
2135                   nits--;
2136                 else if (s.t[col] != d.t[col] || s.r[col] != d.r[col])
2137                   nits++;
2138
2139               if (nits > 8) /* XXX: arbitrary choice */
2140                 {
2141                   for (col = ncol; col--; )
2142                     {
2143                       *d.t++ = *d2.t++;
2144                       *d.r++ = *d2.r++;
2145                     }
2146
2147                   if (len == -1)
2148                     len = row;
2149
2150                   wlen = row;
2151                   continue;
2152                 }
2153             }
2154
2155           if (len >= 0)
2156             {
2157               /* also comes here at end if needed because of >= above */
2158               if (wlen < len)
2159                 ::swap (wlen, len);
2160
2161               XGCValues gcv;
2162
2163               gcv.graphics_exposures = 1; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
2164               XCopyArea (dpy, vt, vt,
2165                          gc, 0, Row2Pixel (len + i),
2166                          (unsigned int)this->width,
2167                          (unsigned int)Height2Pixel (wlen - len + 1),
2168                          0, Row2Pixel (len));
2169               gcv.graphics_exposures = 0; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
2170
2171               len = -1;
2172             }
2173         }
2174     }
2175 #endif
2176
2177   /*
2178    * E: main pass across every character
2179    */
2180   for (row = 0; row < nrow; row++)
2181     {
2182       text_t *stp = ROW(view_start + row).t;
2183       rend_t *srp = ROW(view_start + row).r;
2184       text_t *dtp = drawn_buf[row].t;
2185       rend_t *drp = drawn_buf[row].r;
2186
2187       /*
2188        * E2: OK, now the real pass
2189        */
2190       int ypixel = (int)Row2Pixel (row);
2191
2192       for (col = 0; col < ncol; col++)
2193         {
2194           /* compare new text with old - if exactly the same then continue */
2195           if (stp[col] == dtp[col]    /* Must match characters to skip. */
2196               && (RS_SAME (srp[col], drp[col])    /* Either rendition the same or   */
2197                   || (stp[col] == ' ' /* space w/ no background change  */
2198                       && GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
2199             continue;
2200
2201           // redraw one or more characters
2202
2203           // seek to the beginning of wide characters
2204           while (stp[col] == NOCHAR && col > 0)
2205             --col;
2206
2207           rend_t rend = srp[col];     /* screen rendition (target rendtion) */
2208           text_t *text = stp + col;
2209           int count = 1;
2210
2211           dtp[col] = stp[col];
2212           drp[col] = rend;
2213
2214           int xpixel = Col2Pixel (col);
2215
2216           for (i = 0; ++col < ncol; )
2217             {
2218               if (stp[col] == NOCHAR)
2219                 {
2220                   dtp[col] = stp[col];
2221                   drp[col] = rend;
2222                   count++;
2223                   i++;
2224
2225                   continue;
2226                 }
2227
2228               if (!RS_SAME (rend, srp[col]))
2229                 break;
2230
2231               count++;
2232
2233               if (stp[col] != dtp[col]
2234                   || !RS_SAME (srp[col], drp[col]))
2235                 {
2236                   if (have_bg && (i++ > count / 2))
2237                     break;
2238
2239                   dtp[col] = stp[col];
2240                   drp[col] = rend;
2241                   i = 0;
2242                 }
2243               else if (have_bg || (stp[col] != ' ' && ++i >= 16))
2244                 break;
2245             }
2246
2247           col--;      /* went one too far.  move back */
2248           count -= i; /* dump any matching trailing chars */
2249
2250           // sometimes we optimize away the trailing NOCHAR's, add them back
2251           while (i && text[count] == NOCHAR)
2252             count++, i--;
2253
2254           /*
2255            * Determine the attributes for the string
2256            */
2257           int fore = fgcolor_of (rend); // desired foreground
2258           int back = bgcolor_of (rend); // desired background
2259
2260           // only do special processing if any attributes are set, which is unlikely
2261           if (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful))
2262             {
2263               bool invert = rend & RS_RVid;
2264
2265 #ifndef NO_BOLD_UNDERLINE_REVERSE
2266               if (rend & RS_Bold
2267                   && fore == Color_fg)
2268                 {
2269                   if (ISSET_PIXCOLOR (Color_BD))
2270                     fore = Color_BD;
2271 # if !ENABLE_STYLES
2272                   else
2273                     invert = !invert;
2274 # endif
2275                 }
2276
2277               if (rend & RS_Italic
2278                   && fore == Color_fg)
2279                 {
2280                   if (ISSET_PIXCOLOR (Color_IT))
2281                     fore = Color_IT;
2282 # if !ENABLE_STYLES
2283                   else
2284                     invert = !invert;
2285 # endif
2286                 }
2287
2288               if (rend & RS_Uline && fore == Color_fg && ISSET_PIXCOLOR (Color_UL))
2289                 fore = Color_UL;
2290 #endif
2291
2292               if (invert)
2293                 {
2294 #ifdef OPTION_HC
2295                   if ((showcursor && row == screen.cur.row && text - stp == screen.cur.col)
2296                       || !ISSET_PIXCOLOR (Color_HC))
2297 #endif
2298                     /* invert the column if no highlightColor is set or it is the
2299                      * current cursor column */
2300                     ::swap (fore, back);
2301 #ifdef OPTION_HC
2302                   else if (ISSET_PIXCOLOR (Color_HC))
2303                     back = Color_HC;
2304 #endif
2305
2306 #ifndef NO_BOLD_UNDERLINE_REVERSE
2307 # ifndef OPTION_HC
2308                   if (ISSET_PIXCOLOR (Color_RV))
2309                     back = Color_RV;
2310 # endif
2311                   if (fore == back)
2312                     {
2313                       fore = Color_bg;
2314                       back = Color_fg;
2315                     }
2316 #endif
2317                 }
2318
2319 #ifdef TEXT_BLINK
2320               if (rend & RS_Blink && (back == Color_bg || fore == Color_bg))
2321                 {
2322                   if (!text_blink_ev.active)
2323                     {
2324                       text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
2325                       hidden_text = 0;
2326                     }
2327                   else if (hidden_text)
2328                     fore = back;
2329                 }
2330 #endif
2331
2332 #if ENABLE_STYLES
2333               // "careful" (too wide) character handling
2334
2335               // include previous careful character(s) if possible, looks nicer (best effort...)
2336               while (text > stp
2337                   && srp[text - stp - 1] & RS_Careful
2338                   && RS_SAME (rend, srp[text - stp - 1]))
2339                 text--, count++, xpixel -= fwidth;
2340
2341               // force redraw after "careful" characters to avoid pixel droppings
2342               for (int i = 0; srp[col + i] & RS_Careful && col + i < ncol - 1; i++)
2343                 drp[col + i + 1] = srp[col + i + 1] ^ RS_redraw;
2344
2345               // force redraw before "careful" characters to avoid pixel droppings
2346               for (int i = 0; srp[text - stp - i] & RS_Careful && text - i > stp; i++)
2347                 drp[text - stp - i - 1] = srp[text - stp - i - 1] ^ RS_redraw;
2348 #endif
2349             }
2350
2351           /*
2352            * Actually do the drawing of the string here
2353            */
2354           rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
2355
2356           if (have_bg && back == Color_bg)
2357             {
2358               // this is very ugly, maybe push it into ->draw?
2359
2360               for (i = 0; i < count; i++) /* don't draw empty strings */
2361                 if (text[i] != ' ')
2362                   {
2363                     font->draw (*drawable, xpixel, ypixel, text, count, fore, Color_transparent);
2364                     goto did_clear;
2365                   }
2366
2367               CLEAR_CHARS (xpixel, ypixel, count);
2368               did_clear: ;
2369             }
2370           else
2371             font->draw (*drawable, xpixel, ypixel, text, count, fore, back);
2372
2373           if (rend & RS_Uline && font->descent > 1 && fore != back)
2374             {
2375 #if ENABLE_FRILLS
2376               if (ISSET_PIXCOLOR (Color_underline))
2377                 XSetForeground (dpy, gc, pix_colors[Color_underline]);
2378               else
2379 #endif
2380                 XSetForeground (dpy, gc, pix_colors[fore]);
2381
2382               XDrawLine (dpy, drawBuffer, gc,
2383                          xpixel, ypixel + font->ascent + 1,
2384                          xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2385             }
2386         }                     /* for (col....) */
2387     }                         /* for (row....) */
2388
2389 #if ENABLE_OVERLAY
2390   scr_swap_overlay ();
2391 #endif
2392   HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
2393
2394   /*
2395    * G: cleanup cursor and display outline cursor if necessary
2396    */
2397   if (showcursor)
2398     {
2399       if (focus)
2400         {
2401           if (option (Opt_cursorUnderline))
2402             *crp ^= RS_Uline;
2403           else
2404             {
2405               *crp ^= RS_RVid;
2406 #ifndef NO_CURSORCOLOR
2407               *crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2408 #endif
2409             }
2410         }
2411       else if (oldcursor.row >= 0)
2412         {
2413           int cursorwidth = 1;
2414           int col = oldcursor.col;
2415
2416           while (col && ROW(screen.cur.row).t[col] == NOCHAR)
2417             col--;
2418
2419           while (col + cursorwidth < ncol
2420                  && drawn_buf[oldcursor.row].t[col + cursorwidth] == NOCHAR)
2421             cursorwidth++;
2422
2423 #ifndef NO_CURSORCOLOR
2424           if (ISSET_PIXCOLOR (Color_cursor))
2425             XSetForeground (dpy, gc, pix_colors[Color_cursor]);
2426           else
2427 #endif
2428             XSetForeground (dpy, gc, pix_colors[ccol1]);
2429
2430           XDrawRectangle (dpy, drawBuffer, gc,
2431                           Col2Pixel (col),
2432                           Row2Pixel (oldcursor.row),
2433                           (unsigned int) (Width2Pixel (cursorwidth) - 1),
2434                           (unsigned int) (Height2Pixel (1) - lineSpace - 1));
2435         }
2436     }
2437
2438   /*
2439    * H: cleanup selection
2440    */
2441   scr_reverse_selection ();
2442
2443   num_scr = 0;
2444   num_scr_allow = 1;
2445 }
2446
2447 void
2448 rxvt_term::scr_remap_chars (line_t &l) NOTHROW
2449 {
2450   if (!l.t)
2451     return;
2452
2453   l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
2454
2455   for (int i = ncol; i--; )
2456     l.r[i] = SET_FONT (l.r[i], FONTSET (l.r[i])->find_font (l.t[i]));
2457 }
2458
2459 void
2460 rxvt_term::scr_remap_chars () NOTHROW
2461 {
2462   for (int i = total_rows; i--; )
2463     scr_remap_chars (row_buf [i]);
2464
2465   for (int i = nrow; i--; )
2466     {
2467       scr_remap_chars (drawn_buf [i]);
2468       scr_remap_chars (swap_buf [i]);
2469     }
2470 }
2471
2472 void
2473 rxvt_term::scr_recolour () NOTHROW
2474 {
2475 #ifdef HAVE_BG_PIXMAP
2476   bgPixmap.apply ();
2477 #else
2478   XSetWindowBackground (dpy, parent[0], pix_colors[Color_border]);
2479   XClearWindow (dpy, parent[0]);
2480   XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
2481 # if HAVE_SCROLLBARS
2482   if (scrollBar.win)
2483    {
2484      XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
2485      scrollBar.setIdle ();
2486      scrollbar_show (0);
2487    }
2488 # endif
2489   scr_clear ();
2490   scr_touch (true);
2491   want_refresh = 1;
2492 #endif
2493
2494 }
2495
2496 /* ------------------------------------------------------------------------- */
2497 void
2498 rxvt_term::scr_clear (bool really) NOTHROW
2499 {
2500   if (!mapped)
2501     return;
2502
2503   num_scr_allow = 0;
2504   want_refresh = 1;
2505
2506   if (really)
2507     XClearWindow (dpy, vt);
2508 }
2509
2510 void
2511 rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle1, rend_t rstyle2) NOTHROW
2512 {
2513   int view_end = view_start + nrow;
2514   int row, col;
2515
2516   for (row = max (beg_row, view_start); row <= min (end_row, view_end); row++)
2517     {
2518       text_t *stp = ROW(row).t;
2519       rend_t *srp = ROW(row).r;
2520
2521       for (col = beg_col; col < end_col; col++)
2522         srp[col] ^= rstyle1;
2523
2524       while (col-- > beg_col && (stp[col] == NOCHAR || unicode::is_space (stp[col])))
2525         srp[col] ^= rstyle2;
2526
2527       if (++col < end_col)
2528         srp[col] ^= rstyle2;
2529     }
2530 }
2531
2532 void
2533 rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle) NOTHROW
2534 {
2535   int view_end = view_start + nrow;
2536   int row, col;
2537
2538   if (beg_row >= view_start)
2539     {
2540       col = beg_col;
2541       row = beg_row;
2542     }
2543   else
2544     {
2545       col = 0;
2546       row = view_start;
2547     }
2548
2549   for (; row < min (end_row, view_end); row++, col = 0)
2550     for (rend_t *srp = ROW(row).r; col < ncol; col++)
2551       srp[col] ^= rstyle;
2552
2553   if (row == end_row)
2554     for (rend_t *srp = ROW(row).r; col < end_col; col++)
2555       srp[col] ^= rstyle;
2556 }
2557
2558 /* ------------------------------------------------------------------------- */
2559 void
2560 rxvt_term::scr_reverse_selection () NOTHROW
2561 {
2562   if (selection.op
2563       && current_screen == selection.screen
2564       && selection.end.row >= view_start)
2565     {
2566 #if !ENABLE_MINIMAL
2567       if (selection.rect)
2568         scr_xor_rect (selection.beg.row, selection.beg.col,
2569                       selection.end.row, selection.end.col,
2570                       RS_RVid, RS_RVid | RS_Uline);
2571       else
2572 #endif
2573         scr_xor_span (selection.beg.row, selection.beg.col,
2574                       selection.end.row, selection.end.col,
2575                       RS_RVid);
2576     }
2577 }
2578
2579 /* ------------------------------------------------------------------------- */
2580 /*
2581  * Dump the whole scrollback and screen to the passed filedescriptor.  The
2582  * invoking routine must close the fd.
2583  */
2584 #if 0
2585 void
2586 rxvt_term::scr_dump (int fd) NOTHROW
2587 {
2588   int             row, wrote;
2589   unsigned int    width, towrite;
2590   char            r1[] = "\n";
2591
2592   for (row = saveLines - nsaved;
2593        row < saveLines + nrow - 1; row++)
2594     {
2595       width = row_buf[row].l >= 0 ? row_buf[row].l
2596               : ncol;
2597       for (towrite = width; towrite; towrite -= wrote)
2598         {
2599           wrote = write (fd, & (row_buf[row].t[width - towrite]),
2600                         towrite);
2601           if (wrote < 0)
2602             return;         /* XXX: death, no report */
2603         }
2604       if (row_buf[row].l >= 0)
2605         if (write (fd, r1, 1) <= 0)
2606           return; /* XXX: death, no report */
2607     }
2608 }
2609 #endif
2610 \f
2611 /* ------------------------------------------------------------------------- *
2612  *                           CHARACTER SELECTION                             *
2613  * ------------------------------------------------------------------------- */
2614 void
2615 rxvt_term::selection_check (int check_more) NOTHROW
2616 {
2617   row_col_t pos;
2618
2619   if (!selection.op)
2620     return;
2621
2622   pos.row = pos.col = 0;
2623   if (!IN_RANGE_EXC (selection.beg.row, top_row, nrow)
2624       || !IN_RANGE_EXC (selection.mark.row, top_row, nrow)
2625       || !IN_RANGE_EXC (selection.end.row, top_row, nrow)
2626       || (check_more == 1
2627           && current_screen == selection.screen
2628           && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
2629           && ROWCOL_IS_BEFORE (screen.cur, selection.end))
2630       || (check_more == 2
2631           && ROWCOL_IS_BEFORE (selection.beg, pos)
2632           && ROWCOL_IS_AFTER (selection.end, pos))
2633       || (check_more == 3
2634           && ROWCOL_IS_AFTER (selection.end, pos))
2635       || (check_more == 4     /* screen width change */
2636           && (selection.beg.row != selection.end.row
2637               || selection.end.col > ncol)))
2638     CLEAR_SELECTION ();
2639 }
2640
2641 /* ------------------------------------------------------------------------- */
2642 /*
2643  * Paste a selection direct to the command fd
2644  */
2645 void
2646 rxvt_term::paste (char *data, unsigned int len) NOTHROW
2647 {
2648   /* convert normal newline chars into common keyboard Return key sequence */
2649   for (unsigned int i = 0; i < len; i++)
2650     if (data[i] == C0_LF)
2651       data[i] = C0_CR;
2652
2653   tt_write (data, len);
2654 }
2655
2656 /* ------------------------------------------------------------------------- */
2657 /*
2658  * Respond to a notification that a primary selection has been sent
2659  * EXT: SelectionNotify
2660  */
2661 void
2662 rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop) NOTHROW
2663 {
2664   if (prop == None)         /* check for failed XConvertSelection */
2665     {
2666       if ((selection_type & Sel_CompoundText))
2667         {
2668           int selnum = selection_type & Sel_whereMask;
2669
2670           selection_type = 0;
2671           if (selnum != Sel_direct)
2672             selection_request_other (XA_STRING, selnum);
2673         }
2674
2675       if ((selection_type & Sel_UTF8String))
2676         {
2677           int selnum = selection_type & Sel_whereMask;
2678
2679           selection_type = Sel_CompoundText;
2680           if (selnum != Sel_direct)
2681             selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2682           else
2683             selection_type = 0;
2684         }
2685
2686       return;
2687     }
2688
2689   unsigned long bytes_after;
2690   XTextProperty ct;
2691
2692   if (XGetWindowProperty (dpy, win, prop,
2693                           0, PROP_SIZE / 4,
2694                           delete_prop, AnyPropertyType,
2695                           &ct.encoding, &ct.format,
2696                           &ct.nitems, &bytes_after,
2697                           &ct.value) != Success)
2698     {
2699       ct.value = 0;
2700       goto bailout;
2701     }
2702
2703   if (ct.encoding == None)
2704     goto bailout;
2705
2706   if (bytes_after)
2707     {
2708       // fetch and append remaining data
2709       XTextProperty ct2;
2710
2711       if (XGetWindowProperty (dpy, win, prop,
2712                               ct.nitems / 4, (bytes_after + 3) / 4,
2713                               delete_prop, AnyPropertyType,
2714                               &ct2.encoding, &ct2.format,
2715                               &ct2.nitems, &bytes_after,
2716                               &ct2.value) != Success)
2717         goto bailout;
2718
2719       // realloc should be compatible to XFree, here, and elsewhere, too
2720       ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
2721       memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
2722       ct.nitems += ct2.nitems;
2723
2724       XFree (ct2.value);
2725     }
2726
2727   if (ct.value == 0)
2728     goto bailout;
2729
2730   if (ct.encoding == xa[XA_INCR])
2731     {
2732       // INCR selection, start handshake
2733       if (!delete_prop)
2734         XDeleteProperty (dpy, win, prop);
2735
2736       selection_wait = Sel_incr;
2737       incr_buf_fill = 0;
2738       incr_ev.start (NOW + 10);
2739
2740       goto bailout;
2741     }
2742
2743   if (ct.nitems == 0)
2744     {
2745       if (selection_wait == Sel_incr)
2746         {
2747           XFree (ct.value);
2748
2749           // finally complete, now paste the whole thing
2750           selection_wait = Sel_normal;
2751           ct.value = (unsigned char *)incr_buf;
2752           ct.nitems = incr_buf_fill;
2753           incr_buf = 0;
2754           incr_buf_size = 0;
2755           incr_ev.stop ();
2756         }
2757       else
2758         {
2759           if (selection_wait == Sel_normal
2760               && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2761             {
2762               /*
2763                * pass through again trying CUT_BUFFER0 if we've come from
2764                * XConvertSelection () but nothing was presented
2765                */
2766               selection_paste (display->root, XA_CUT_BUFFER0, False);
2767             }
2768
2769           goto bailout;
2770         }
2771     }
2772   else if (selection_wait == Sel_incr)
2773     {
2774       incr_ev.start (NOW + 10);
2775
2776       while (incr_buf_fill + ct.nitems > incr_buf_size)
2777         {
2778           incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
2779           incr_buf = (char *)realloc (incr_buf, incr_buf_size);
2780         }
2781
2782       memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2783       incr_buf_fill += ct.nitems;
2784
2785       goto bailout;
2786     }
2787
2788   char **cl;
2789   int cr;
2790
2791 #if !ENABLE_MINIMAL
2792   // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
2793   // so recode it manually
2794   if (ct.encoding == xa[XA_UTF8_STRING])
2795     {
2796       wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
2797       char *s = rxvt_wcstombs (w);
2798       free (w);
2799       // TODO: strlen == only the first element will be converted. well...
2800       paste (s, strlen (s));
2801       free (s);
2802     }
2803   else
2804 #endif
2805   if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
2806       && cl)
2807     {
2808       for (int i = 0; i < cr; i++)
2809         paste (cl[i], strlen (cl[i]));
2810
2811       XFreeStringList (cl);
2812     }
2813   else
2814     paste ((char *)ct.value, ct.nitems); // paste raw
2815
2816 bailout:
2817   XFree (ct.value);
2818
2819   if (selection_wait == Sel_normal)
2820     selection_wait = Sel_none;
2821 }
2822
2823 void
2824 rxvt_term::incr_cb (time_watcher &w) NOTHROW
2825 {
2826   selection_wait = Sel_none;
2827
2828   incr_buf_size = 0;
2829   free (incr_buf);
2830
2831   rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2832 }
2833
2834 void
2835 rxvt_term::selection_property (Window win, Atom prop) NOTHROW
2836 {
2837   if (prop == None || selection_wait != Sel_incr)
2838     return;
2839
2840   selection_paste (win, prop, true);
2841 }
2842
2843 /* ------------------------------------------------------------------------- */
2844 /*
2845  * Request the current selection:
2846  * Order: > internal selection if available
2847  *        > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
2848  *        > CUT_BUFFER0
2849  * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
2850  *     will auto fallback to CUT_BUFFER0
2851  * EXT: button 2 release
2852  */
2853 void
2854 rxvt_term::selection_request (Time tm, int selnum) NOTHROW
2855 {
2856   if (selection.text && selnum == Sel_Primary)
2857     { /* internal selection */
2858       char *str = rxvt_wcstombs (selection.text, selection.len);
2859       paste (str, strlen (str));
2860       free (str);
2861       return;
2862     }
2863   else
2864     {
2865       selection_request_time = tm;
2866       selection_wait = Sel_normal;
2867
2868 #if X_HAVE_UTF8_STRING
2869       selection_type = Sel_UTF8String;
2870       if (selection_request_other (xa[XA_UTF8_STRING], selnum))
2871         return;
2872 #else
2873       selection_type = Sel_CompoundText;
2874       if (selection_request_other (xa[XA_COMPOUND_TEXT], selnum))
2875         return;
2876 #endif
2877     }
2878
2879   selection_wait = Sel_none;       /* don't loop in selection_paste () */
2880   selection_paste (display->root, XA_CUT_BUFFER0, false);
2881 }
2882
2883 int
2884 rxvt_term::selection_request_other (Atom target, int selnum) NOTHROW
2885 {
2886   Atom sel;
2887
2888   selection_type |= selnum;
2889
2890   if (selnum == Sel_Primary)
2891     sel = XA_PRIMARY;
2892   else if (selnum == Sel_Secondary)
2893     sel = XA_SECONDARY;
2894   else
2895     sel = xa[XA_CLIPBOARD];
2896
2897   if (XGetSelectionOwner (dpy, sel) != None)
2898     {
2899       XConvertSelection (dpy, sel, target, xa[XA_VT_SELECTION],
2900                          vt, selection_request_time);
2901       return 1;
2902     }
2903
2904   return 0;
2905 }
2906
2907 /* ------------------------------------------------------------------------- */
2908 /*
2909  * Clear all selected text
2910  * EXT: SelectionClear
2911  */
2912 void
2913 rxvt_term::selection_clear () NOTHROW
2914 {
2915   want_refresh = 1;
2916   free (selection.text);
2917   selection.text = NULL;
2918   selection.len = 0;
2919   CLEAR_SELECTION ();
2920
2921   if (display->selection_owner == this)
2922     display->selection_owner = 0;
2923 }
2924
2925 /* ------------------------------------------------------------------------- */
2926 /*
2927  * Copy a selection into the cut buffer
2928  * EXT: button 1 or 3 release
2929  */
2930 void
2931 rxvt_term::selection_make (Time tm)
2932 {
2933   int i;
2934   wchar_t *new_selection_text;
2935   text_t *t;
2936
2937   switch (selection.op)
2938     {
2939       case SELECTION_CONT:
2940         break;
2941       case SELECTION_INIT:
2942         CLEAR_SELECTION ();
2943         /* FALLTHROUGH */
2944       case SELECTION_BEGIN:
2945         selection.op = SELECTION_DONE;
2946         /* FALLTHROUGH */
2947       default:
2948         return;
2949     }
2950
2951   selection.op = SELECTION_DONE;
2952
2953   if (selection.clicks == 4)
2954     return;                 /* nothing selected, go away */
2955
2956   if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
2957     return;
2958
2959   i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
2960   new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2961
2962   int ofs = 0;
2963   int extra = 0;
2964
2965   int col = selection.beg.col;
2966   int row = selection.beg.row;
2967
2968   int end_col;
2969
2970   for (; row <= selection.end.row; row++, col = 0)
2971     {
2972 #if !ENABLE_MINIMAL
2973       if (selection.rect)
2974         {
2975           col = selection.beg.col;
2976           end_col = ncol + 1;
2977         }
2978       else
2979 #endif
2980         end_col = ROW(row).l;
2981
2982       col = max (col, 0);
2983
2984       if (row == selection.end.row
2985 #if !ENABLE_MINIMAL
2986           || selection.rect
2987 #endif
2988           )
2989         min_it (end_col, selection.end.col);
2990
2991       t = ROW(row).t + col;
2992
2993       for (; col < end_col; col++)
2994         {
2995           if (*t == NOCHAR)
2996             t++;
2997 #if ENABLE_COMBINING
2998           else if (IS_COMPOSE (*t))
2999             {
3000               int len = rxvt_composite.expand (*t, 0);
3001
3002               extra -= (len - 1);
3003
3004               if (extra < 0)
3005                 {
3006                   extra += i;
3007                   i += i;
3008                   new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
3009                 }
3010
3011               ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
3012             }
3013 #endif
3014           else
3015             new_selection_text[ofs++] = *t++;
3016         }
3017
3018 #if !ENABLE_MINIMAL
3019       if (selection.rect)
3020         {
3021           while (ofs
3022                  && new_selection_text[ofs - 1] != C0_LF
3023                  && unicode::is_space (new_selection_text[ofs - 1]))
3024             --ofs;
3025
3026           new_selection_text[ofs++] = C0_LF;
3027         }
3028       else
3029 #endif
3030         if (!ROW(row).is_longer () && row != selection.end.row)
3031           new_selection_text[ofs++] = C0_LF;
3032     }
3033
3034   if (end_col != selection.end.col)
3035     new_selection_text[ofs++] = C0_LF;
3036
3037   new_selection_text[ofs] = 0;
3038
3039   if (ofs == 0)
3040     {
3041       free (new_selection_text);
3042       return;
3043     }
3044
3045   free (selection.text);
3046
3047   // we usually allocate much more than necessary, so realloc it smaller again
3048   selection.len = ofs;
3049   selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
3050
3051   if (HOOK_INVOKE ((this, HOOK_SEL_GRAB, DT_LONG, (long)tm, DT_END)))
3052     return;
3053
3054   selection_grab (tm);
3055 }
3056
3057 bool
3058 rxvt_term::selection_grab (Time tm) NOTHROW
3059 {
3060   selection_time = tm;
3061
3062   XSetSelectionOwner (dpy, XA_PRIMARY, vt, tm);
3063   if (XGetSelectionOwner (dpy, XA_PRIMARY) == vt)
3064     {
3065       display->set_selection_owner (this);
3066       return true;
3067     }
3068   else
3069     {
3070       selection_clear ();
3071       return false;
3072     }
3073
3074 #if 0
3075   XTextProperty ct;
3076
3077   if (XwcTextListToTextProperty (dpy, &selection.text, 1, XStringStyle, &ct) >= 0)
3078     {
3079       set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
3080       XFree (ct.value);
3081     }
3082 #endif
3083 }
3084
3085 /* ------------------------------------------------------------------------- */
3086 /*
3087  * Mark or select text based upon number of clicks: 1, 2, or 3
3088  * EXT: button 1 press
3089  */
3090 void
3091 rxvt_term::selection_click (int clicks, int x, int y) NOTHROW
3092 {
3093   clicks = ((clicks - 1) % 3) + 1;
3094   selection.clicks = clicks;       /* save clicks so extend will work */
3095
3096   if (clicks == 2 && !selection.rect
3097       && HOOK_INVOKE ((this, HOOK_SEL_EXTEND, DT_END)))
3098     {
3099       MEvent.clicks = 1; // what a mess
3100       selection.screen = current_screen;
3101       selection.op = SELECTION_CONT;
3102       return;
3103     }
3104
3105   selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
3106
3107   if (clicks == 2 || clicks == 3)
3108     selection_extend_colrow (selection.mark.col,
3109                              selection.mark.row - view_start,
3110                              0, /* button 3     */
3111                              1, /* button press */
3112                              0);        /* click change */
3113 }
3114
3115 /* ------------------------------------------------------------------------- */
3116 /*
3117  * Mark a selection at the specified col/row
3118  */
3119 void
3120 rxvt_term::selection_start_colrow (int col, int row) NOTHROW
3121 {
3122   want_refresh = 1;
3123
3124   selection.mark.row = row + view_start;
3125   selection.mark.col = col;
3126
3127   selection.mark.row = clamp (selection.mark.row, top_row, nrow - 1);
3128   selection.mark.col = clamp (selection.mark.col,       0, ncol - 1);
3129
3130   while (selection.mark.col > 0
3131          && ROW(selection.mark.row).t[selection.mark.col] == NOCHAR)
3132     --selection.mark.col;
3133
3134   if (selection.op)
3135     {      /* clear the old selection */
3136       selection.beg.row = selection.end.row = selection.mark.row;
3137       selection.beg.col = selection.end.col = selection.mark.col;
3138     }
3139
3140   selection.op = SELECTION_INIT;
3141   selection.screen = current_screen;
3142 }
3143
3144 /* ------------------------------------------------------------------------- */
3145 /*
3146  * Word select: select text for 2 clicks
3147  * We now only find out the boundary in one direction
3148  */
3149
3150 /* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
3151 #define DELIMIT_TEXT(x)                 \
3152     (unicode::is_space (x) ? 2 : (x) <= 0xff && !!strchr (rs[Rs_cutchars], (x)))
3153 #define DELIMIT_REND(x)        1
3154
3155 void
3156 rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret) NOTHROW
3157 {
3158   int col, row, dirnadd, tcol, trow, w1, w2;
3159   row_col_t bound;
3160   text_t *stp;
3161   rend_t *srp;
3162
3163   if (dirn == UP)
3164     {
3165       bound.row = top_row - 1;
3166       bound.col = 0;
3167       dirnadd = -1;
3168     }
3169   else
3170     {
3171       bound.row = nrow;
3172       bound.col = ncol - 1;
3173       dirnadd = 1;
3174     }
3175
3176   row = mark->row;
3177   col = max (mark->col, 0);
3178
3179   /* find the edge of a word */
3180   stp = ROW(row).t + col; w1 = DELIMIT_TEXT (*stp);
3181   srp = ROW(row).r + col; w2 = DELIMIT_REND (*srp);
3182
3183   for (;;)
3184     {
3185       for (; col != bound.col; col += dirnadd)
3186         {
3187           stp += dirnadd;
3188           srp += dirnadd;
3189
3190           if (*stp == NOCHAR)
3191             continue;
3192
3193           if (DELIMIT_TEXT (*stp) != w1)
3194             break;
3195           if (DELIMIT_REND (*srp) != w2)
3196             break;
3197         }
3198
3199       if ((col == bound.col) && (row != bound.row))
3200         {
3201           if (ROW(row - (dirn == UP ? 1 : 0)).is_longer ())
3202             {
3203               trow = row + dirnadd;
3204               tcol = dirn == UP ? ncol - 1 : 0;
3205
3206               if (!ROW(trow).t)
3207                 break;
3208
3209               stp = ROW(trow).t + tcol;
3210               srp = ROW(trow).r + tcol;
3211
3212               if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
3213                 break;
3214
3215               row = trow;
3216               col = tcol;
3217               continue;
3218             }
3219         }
3220       break;
3221     }
3222
3223   if (dirn == DN)
3224     col++;                  /* put us on one past the end */
3225
3226   /* Poke the values back in */
3227   ret->row = row;
3228   ret->col = col;
3229 }
3230
3231 /* ------------------------------------------------------------------------- */
3232 /*
3233  * Extend the selection to the specified x/y pixel location
3234  * EXT: button 3 press; button 1 or 3 drag
3235  * flag == 0 ==> button 1
3236  * flag == 1 ==> button 3 press
3237  * flag == 2 ==> button 3 motion
3238  */
3239 void
3240 rxvt_term::selection_extend (int x, int y, int flag) NOTHROW
3241 {
3242   int col = clamp (Pixel2Col (x), 0, ncol);
3243   int row = clamp (Pixel2Row (y), 0, nrow - 1);
3244
3245   /*
3246   * If we're selecting characters (single click) then we must check first
3247   * if we are at the same place as the original mark.  If we are then
3248   * select nothing.  Otherwise, if we're to the right of the mark, you have to
3249   * be _past_ a character for it to be selected.
3250   */
3251   if (((selection.clicks % 3) == 1) && !flag
3252       && (col == selection.mark.col
3253           && (row == selection.mark.row - view_start)))
3254     {
3255       /* select nothing */
3256       selection.beg.row = selection.end.row = 0;
3257       selection.beg.col = selection.end.col = 0;
3258       selection.clicks = 4;
3259       want_refresh = 1;
3260       return;
3261     }
3262
3263   if (selection.clicks == 4)
3264     selection.clicks = 1;
3265
3266   selection_extend_colrow (col, row, !!flag,  /* ? button 3      */
3267                            flag == 1 ? 1 : 0,     /* ? button press  */
3268                            0);    /* no click change */
3269 }
3270
3271 /* ------------------------------------------------------------------------- */
3272 /*
3273  * Extend the selection to the specified col/row
3274  */
3275 void
3276 rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange) NOTHROW
3277 {
3278   row_col_t pos;
3279   enum {
3280     LEFT, RIGHT
3281   } closeto = RIGHT;
3282
3283   want_refresh = 1;
3284
3285   switch (selection.op)
3286     {
3287       case SELECTION_INIT:
3288         CLEAR_SELECTION ();
3289         selection.op = SELECTION_BEGIN;
3290         /* FALLTHROUGH */
3291       case SELECTION_BEGIN:
3292         if (row != selection.mark.row || col != selection.mark.col
3293             || (!button3 && buttonpress))
3294           selection.op = SELECTION_CONT;
3295         break;
3296       case SELECTION_DONE:
3297         selection.op = SELECTION_CONT;
3298         /* FALLTHROUGH */
3299       case SELECTION_CONT:
3300         break;
3301       case SELECTION_CLEAR:
3302         selection_start_colrow (col, row);
3303         /* FALLTHROUGH */
3304       default:
3305         return;
3306     }
3307
3308   if (selection.beg.col == selection.end.col
3309       && selection.beg.col != selection.mark.col
3310       && selection.beg.row == selection.end.row
3311       && selection.beg.row != selection.mark.row)
3312     {
3313       selection.beg.col = selection.end.col = selection.mark.col;
3314       selection.beg.row = selection.end.row = selection.mark.row;
3315     }
3316
3317   pos.col = col;
3318   pos.row = view_start + row;
3319
3320   /*
3321    * This is mainly xterm style selection with a couple of differences, mainly
3322    * in the way button3 drag extension works.
3323    * We're either doing: button1 drag; button3 press; or button3 drag
3324    *  a) button1 drag : select around a midpoint/word/line - that point/word/line
3325    *     is always at the left/right edge of the selection.
3326    *  b) button3 press: extend/contract character/word/line at whichever edge of
3327    *     the selection we are closest to.
3328    *  c) button3 drag : extend/contract character/word/line - we select around
3329    *     a point/word/line which is either the start or end of the selection
3330    *     and it was decided by whichever point/word/line was `fixed' at the
3331    *     time of the most recent button3 press
3332    */
3333   if (button3 && buttonpress)
3334     { /* button3 press */
3335       /*
3336        * first determine which edge of the selection we are closest to
3337        */
3338       if (ROWCOL_IS_BEFORE (pos, selection.beg)
3339           || (!ROWCOL_IS_AFTER (pos, selection.end)
3340               && (((pos.col - selection.beg.col)
3341                    + ((pos.row - selection.beg.row) * ncol))
3342                   < ((selection.end.col - pos.col)
3343                      + ((selection.end.row - pos.row) * ncol)))))
3344         closeto = LEFT;
3345
3346       if (closeto == LEFT)
3347         {
3348           selection.beg.row = pos.row;
3349           selection.beg.col = pos.col;
3350           selection.mark.row = selection.end.row;
3351           selection.mark.col = selection.end.col - (selection.clicks == 2);
3352         }
3353       else
3354         {
3355           selection.end.row = pos.row;
3356           selection.end.col = pos.col;
3357           selection.mark.row = selection.beg.row;
3358           selection.mark.col = selection.beg.col;
3359         }
3360     }
3361   else
3362     { /* button1 drag or button3 drag */
3363       if (ROWCOL_IS_AFTER (selection.mark, pos))
3364         {
3365           if (selection.mark.row == selection.end.row
3366               && selection.mark.col == selection.end.col
3367               && clickchange
3368               && selection.clicks == 2)
3369             selection.mark.col--;
3370
3371           selection.beg.row = pos.row;
3372           selection.beg.col = pos.col;
3373           selection.end.row = selection.mark.row;
3374           selection.end.col = selection.mark.col + (selection.clicks == 2);
3375         }
3376       else
3377         {
3378           selection.beg.row = selection.mark.row;
3379           selection.beg.col = selection.mark.col;
3380           selection.end.row = pos.row;
3381           selection.end.col = pos.col;
3382         }
3383     }
3384
3385   if (selection.clicks == 1)
3386     {
3387       if (selection.beg.col > ROW(selection.beg.row).l //TODO//FIXME//LEN
3388           && !ROW(selection.beg.row).is_longer ()
3389 #if !ENABLE_MINIMAL
3390           && !selection.rect
3391 #endif
3392          )
3393         selection.beg.col = ncol;
3394
3395       if (
3396           selection.end.col > ROW(selection.end.row).l //TODO//FIXME//LEN
3397           && !ROW(selection.end.row).is_longer ()
3398 #if !ENABLE_MINIMAL
3399           && !selection.rect
3400 #endif
3401          )
3402         selection.end.col = ncol;
3403     }
3404   else if (selection.clicks == 2)
3405     {
3406       if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3407         selection.end.col--;
3408
3409       selection_delimit_word (UP, &selection.beg, &selection.beg);
3410       selection_delimit_word (DN, &selection.end, &selection.end);
3411     }
3412   else if (selection.clicks == 3)
3413     {
3414 #if ENABLE_FRILLS
3415       if (option (Opt_tripleclickwords))
3416         {
3417           selection_delimit_word (UP, &selection.beg, &selection.beg);
3418
3419           for (int end_row = selection.mark.row; end_row < nrow; end_row++)
3420             {
3421               if (!ROW(end_row).is_longer ())
3422                 {
3423                   selection.end.row = end_row;
3424                   selection.end.col = ROW(end_row).l;
3425 # if !ENABLE_MINIMAL
3426                   selection_remove_trailing_spaces ();
3427 # endif
3428                   break;
3429                 }
3430             }
3431         }
3432       else
3433 #endif
3434         {
3435           if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3436             selection.mark.col++;
3437
3438           selection.beg.col = 0;
3439           selection.end.col = ncol;
3440
3441           // select a complete logical line
3442           while (selection.beg.row > -saveLines
3443                  && ROW(selection.beg.row - 1).is_longer ())
3444             selection.beg.row--;
3445
3446           while (selection.end.row < nrow
3447                  && ROW(selection.end.row).is_longer ())
3448             selection.end.row++;
3449         }
3450     }
3451
3452   if (button3 && buttonpress)
3453     { /* mark may need to be changed */
3454       if (closeto == LEFT)
3455         {
3456           selection.mark.row = selection.end.row;
3457           selection.mark.col = selection.end.col - (selection.clicks == 2);
3458         }
3459       else
3460         {
3461           selection.mark.row = selection.beg.row;
3462           selection.mark.col = selection.beg.col;
3463         }
3464     }
3465
3466 #if !ENABLE_MINIMAL
3467   if (selection.rect && selection.beg.col > selection.end.col)
3468     ::swap (selection.beg.col, selection.end.col);
3469 #endif
3470 }
3471
3472 #if !ENABLE_MINIMAL
3473 void
3474 rxvt_term::selection_remove_trailing_spaces () NOTHROW
3475 {
3476   int32_t end_col, end_row;
3477   text_t *stp;
3478
3479   end_col = selection.end.col;
3480   end_row = selection.end.row;
3481
3482   for (; end_row >= selection.beg.row; )
3483     {
3484       stp = ROW(end_row).t;
3485
3486       while (--end_col >= 0)
3487         {
3488           if (stp[end_col] != NOCHAR
3489               && !unicode::is_space (stp[end_col]))
3490             break;
3491         }
3492
3493       if (end_col >= 0
3494           || !ROW(end_row - 1).is_longer ())
3495         {
3496           selection.end.col = end_col + 1;
3497           selection.end.row = end_row;
3498           break;
3499         }
3500
3501       end_row--;
3502       end_col = ncol;
3503     }
3504
3505   if (selection.mark.row > selection.end.row)
3506     {
3507       selection.mark.row = selection.end.row;
3508       selection.mark.col = selection.end.col;
3509     }
3510   else if (selection.mark.row == selection.end.row
3511            && selection.mark.col > selection.end.col)
3512     selection.mark.col = selection.end.col;
3513 }
3514 #endif
3515
3516 /* ------------------------------------------------------------------------- */
3517 /*
3518  * Double click on button 3 when already selected
3519  * EXT: button 3 double click
3520  */
3521 void
3522 rxvt_term::selection_rotate (int x, int y) NOTHROW
3523 {
3524   selection.clicks = selection.clicks % 3 + 1;
3525   selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
3526 }
3527
3528 /* ------------------------------------------------------------------------- */
3529 /*
3530  * Respond to a request for our current selection
3531  * EXT: SelectionRequest
3532  */
3533 void
3534 rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
3535 {
3536   XSelectionEvent ev;
3537
3538   ev.type = SelectionNotify;
3539   ev.property = None;
3540   ev.display = rq.display;
3541   ev.requestor = rq.requestor;
3542   ev.selection = rq.selection;
3543   ev.target = rq.target;
3544   ev.time = rq.time;
3545
3546   if (rq.target == xa[XA_TARGETS])
3547     {
3548       Atom target_list[6];
3549       Atom *target = target_list;
3550
3551       *target++ = xa[XA_TARGETS];
3552       *target++ = xa[XA_TIMESTAMP];
3553       *target++ = XA_STRING;
3554       *target++ = xa[XA_TEXT];
3555       *target++ = xa[XA_COMPOUND_TEXT];
3556 #if X_HAVE_UTF8_STRING
3557       *target++ = xa[XA_UTF8_STRING];
3558 #endif
3559
3560       XChangeProperty (dpy, rq.requestor, rq.property, XA_ATOM,
3561                        32, PropModeReplace,
3562                        (unsigned char *)target_list, target - target_list);
3563       ev.property = rq.property;
3564     }
3565 #if TODO // TODO
3566   else if (rq.target == xa[XA_MULTIPLE])
3567     {
3568       /* TODO: Handle MULTIPLE */
3569     }
3570 #endif
3571   else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3572     {
3573       XChangeProperty (dpy, rq.requestor, rq.property, rq.target,
3574                        32, PropModeReplace, (unsigned char *)&selection_time, 1);
3575       ev.property = rq.property;
3576     }
3577   else if (rq.target == XA_STRING
3578            || rq.target == xa[XA_TEXT]
3579            || rq.target == xa[XA_COMPOUND_TEXT]
3580            || rq.target == xa[XA_UTF8_STRING]
3581           )
3582     {
3583       XTextProperty ct;
3584       Atom target = rq.target;
3585       short freect = 0;
3586       int selectlen;
3587       wchar_t *cl;
3588       enum {
3589         enc_string        = XStringStyle,
3590         enc_text          = XStdICCTextStyle,
3591         enc_compound_text = XCompoundTextStyle,
3592 #ifdef X_HAVE_UTF8_STRING
3593         enc_utf8          = XUTF8StringStyle,
3594 #else
3595         enc_utf8          = -1,
3596 #endif
3597       } style;
3598
3599       if (target == XA_STRING)
3600         // we actually don't do XA_STRING, but who cares, as i18n clients
3601         // will ask for another format anyways.
3602         style = enc_string;
3603       else if (target == xa[XA_TEXT])
3604         style = enc_text;
3605       else if (target == xa[XA_COMPOUND_TEXT])
3606         style = enc_compound_text;
3607 #if !ENABLE_MINIMAL
3608       else if (target == xa[XA_UTF8_STRING])
3609         style = enc_utf8;
3610 #endif
3611       else
3612         {
3613           target = xa[XA_COMPOUND_TEXT];
3614           style = enc_compound_text;
3615         }
3616
3617       if (selection.text)
3618         {
3619           cl = selection.text;
3620           selectlen = selection.len;
3621         }
3622       else
3623         {
3624           cl = L"";
3625           selectlen = 0;
3626         }
3627
3628 #if !ENABLE_MINIMAL
3629       // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
3630       // so recode it manually
3631       if (style == enc_utf8)
3632         {
3633           freect = 1;
3634           ct.encoding = target;
3635           ct.format = 8;
3636           ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);
3637           ct.nitems = strlen ((char *)ct.value);
3638         }
3639       else
3640 #endif
3641       if (XwcTextListToTextProperty (dpy, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
3642         freect = 1;
3643       else
3644         {
3645           /* if we failed to convert then send it raw */
3646           ct.value = (unsigned char *)cl;
3647           ct.nitems = selectlen;
3648           ct.encoding = target;
3649         }
3650
3651       XChangeProperty (dpy, rq.requestor, rq.property,
3652                        ct.encoding, 8, PropModeReplace,
3653                        ct.value, (int)ct.nitems);
3654       ev.property = rq.property;
3655
3656       if (freect)
3657         XFree (ct.value);
3658     }
3659
3660   XSendEvent (dpy, rq.requestor, False, 0L, (XEvent *)&ev);
3661 }
3662
3663 /* ------------------------------------------------------------------------- */
3664 #ifdef USE_XIM
3665 void
3666 rxvt_term::im_set_position (XPoint &pos) NOTHROW
3667 {
3668   XWindowAttributes xwa;
3669
3670   XGetWindowAttributes (dpy, vt, &xwa);
3671
3672   pos.x = xwa.x + Col2Pixel    (screen.cur.col);
3673   pos.y = xwa.y + Height2Pixel (screen.cur.row) + fbase;
3674 }
3675 #endif
3676
3677 #if ENABLE_OVERLAY
3678 void
3679 rxvt_term::scr_overlay_new (int x, int y, int w, int h) NOTHROW
3680 {
3681   if (nrow < 1 || ncol < 1)
3682     return;
3683
3684   want_refresh = 1;
3685
3686   scr_overlay_off ();
3687
3688   if (x < 0) x = ncol - w;
3689   if (y < 0) y = nrow - h;
3690
3691   // make space for border
3692   w += 2; min_it (w, ncol);
3693   h += 2; min_it (h, nrow);
3694
3695   x -= 1; clamp_it (x, 0, ncol - w);
3696   y -= 1; clamp_it (y, 0, nrow - h);
3697
3698   ov_x = x; ov_y = y;
3699   ov_w = w; ov_h = h;
3700
3701   ov_text = new text_t *[h];
3702   ov_rend = new rend_t *[h];
3703
3704   for (y = 0; y < h; y++)
3705     {
3706       text_t *tp = ov_text[y] = new text_t[w];
3707       rend_t *rp = ov_rend[y] = new rend_t[w];
3708
3709       text_t t0, t1, t2;
3710       rend_t r = OVERLAY_RSTYLE;
3711
3712       if (y == 0)
3713         t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
3714       else if (y < h - 1)
3715         t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
3716       else
3717         t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
3718
3719       *tp++ = t0;
3720       *rp++ = r;
3721
3722       for (x = w - 2; x > 0; --x)
3723         {
3724           *tp++ = t1;
3725           *rp++ = r;
3726         }
3727
3728       *tp = t2;
3729       *rp = r;
3730     }
3731 }
3732
3733 void
3734 rxvt_term::scr_overlay_off () NOTHROW
3735 {
3736   if (!ov_text)
3737     return;
3738
3739   want_refresh = 1;
3740
3741   for (int y = 0; y < ov_h; y++)
3742     {
3743       delete [] ov_text[y];
3744       delete [] ov_rend[y];
3745     }
3746
3747   delete [] ov_text; ov_text = 0;
3748   delete [] ov_rend; ov_rend = 0;
3749 }
3750
3751 void
3752 rxvt_term::scr_overlay_set (int x, int y, text_t text, rend_t rend) NOTHROW
3753 {
3754   if (!ov_text || x >= ov_w - 2 || y >= ov_h - 2)
3755     return;
3756
3757   x++, y++;
3758
3759   ov_text[y][x] = text;
3760   ov_rend[y][x] = rend;
3761 }
3762
3763 void
3764 rxvt_term::scr_overlay_set (int x, int y, const char *s) NOTHROW
3765 {
3766   while (*s)
3767     scr_overlay_set (x++, y, *s++);
3768 }
3769
3770 void
3771 rxvt_term::scr_overlay_set (int x, int y, const wchar_t *s) NOTHROW
3772 {
3773   while (*s)
3774     {
3775       text_t t = *s++;
3776       int width = WCWIDTH (t);
3777
3778       while (width--)
3779         {
3780           scr_overlay_set (x++, y, t);
3781           t = NOCHAR;
3782         }
3783     }
3784 }
3785
3786 void
3787 rxvt_term::scr_swap_overlay () NOTHROW
3788 {
3789   if (!ov_text)
3790     return;
3791
3792   // swap screen mem with overlay
3793   for (int y = ov_h; y--; )
3794     {
3795       text_t *t1 = ov_text[y];
3796       rend_t *r1 = ov_rend[y];
3797
3798       text_t *t2 = ROW(y + ov_y + view_start).t + ov_x;
3799       rend_t *r2 = ROW(y + ov_y + view_start).r + ov_x;
3800
3801       for (int x = ov_w; x--; )
3802         {
3803           text_t t = *t1; *t1++ = *t2; *t2++ = t;
3804           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, FONTSET (r)->find_font (t));
3805         }
3806     }
3807 }
3808
3809 #endif
3810 /* ------------------------------------------------------------------------- */
3811