src/screen.C

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