src/screen.C

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