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