[ViewVC] Diff of: cvs/rxvt-unicode/src/screen.C

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.190 by root, Thu Dec 22 15:52:57 2005 UTC vs.
Revision 1.220 by root, Mon Jan 9 23:18:49 2006 UTC

 /*--------------------------------*-C-*--------------------------------------*
  * File:        screen.C
  *---------------------------------------------------------------------------*
  *
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
- * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
+ * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  * This file handles _all_ screen updates and selections
  */
 #include "../config.h"          /* NECESSARY */
 #include "rxvt.h"               /* NECESSARY */
+#include "rxvtperl.h"           /* NECESSARY */
 #include <X11/Xmd.h>            /* get the typedef for CARD32 */
 #include <inttypes.h>
 /* ------------------------------------------------------------------------- *
  *             GENERAL SCREEN AND SELECTION UPDATE ROUTINES                  *
  * ------------------------------------------------------------------------- */
 #define ZERO_SCROLLBACK()                                              \
-    if (options & Opt_scrollTtyOutput)                                 \
+    if (OPTION (Opt_scrollTtyOutput))                                  \
         view_start = 0
 #define CLEAR_SELECTION()                                              \
     selection.beg.row = selection.beg.col                              \
         = selection.end.row = selection.end.col = 0
 #define CLEAR_ALL_SELECTION()                                          \
       lalloc (l);
       col = 0;
       width = ncol;
     }
+  l.touch ();
   efs &= ~RS_baseattrMask;
   efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
   text_t *et = l.t + col;
   rend_t *er = l.r + col;
 /* Fill a full line with blanks - make sure it is allocated first */
 void
 rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs)
 {
   scr_blank_line (l, 0, ncol, efs);
+  l.l = 0;
+  l.f = 0;
 }
 /* ------------------------------------------------------------------------- *
  *                          SCREEN INITIALISATION                            *
  * ------------------------------------------------------------------------- */
   if (!row_buf)
     {
       /*
        * first time called so just malloc everything: don't rely on realloc
-       * Note: this is still needed so that all the scrollback lines are NULL
        */
       nsaved = 0;       /* no saved lines */
       term_start = 0;
       talloc = new rxvt_salloc (ncol * sizeof (text_t));
       ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
-      row_buf   = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
+      row_buf   = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
-      temp_buf  = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
-      drawn_buf = (line_t *)rxvt_calloc (nrow      , sizeof (line_t));
+      drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
-      swap_buf  = (line_t *)rxvt_calloc (nrow      , sizeof (line_t));
+      swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
       for (int row = nrow; row--; )
         {
           scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
           scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
             }
         }
 #endif
       drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
-      temp_buf  = (line_t *)rxvt_realloc (temp_buf , nrow * sizeof (line_t));
       swap_buf  = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
       for (int row = min (nrow, prev_nrow); row--; )
         {
           lresize (drawn_buf[row]);
         {
           swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
           drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
         }
+      line_t *old_buf = row_buf;
-      line_t *old_buf = row_buf; row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
+      row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
       int pend = MOD (term_start - nsaved   , prev_total_rows);
       int q    = total_rows; // rewrapped row
           // to come up with a lean and mean algorithm.
           row_col_t ocur = screen.cur;
           ocur.row = MOD (term_start + ocur.row, prev_total_rows);
-          while (p != pend && q > 0)
+          do
             {
               p = MOD (p - 1, prev_total_rows);
 #ifdef DEBUG_STRICT
               assert (old_buf [MOD (p, prev_total_rows)].t);
 #endif
               int plines = 1;
               int llen = old_buf [MOD (p, prev_total_rows)].l;
               while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
                 {
               // re-assemble the full line by destination lines
               for (int qrow = q; qlines--; qrow++)
                 {
                   qline = row_buf + qrow;
                   lalloc (*qline);
+                  qline->l = ncol;
-                  qline->set_is_longer ();
+                  qline->is_longer (1);
                   int qcol = 0;
                   // fill a single destination line
                   while (lofs < llen && qcol < ncol)
                       int prow = lofs / prev_ncol;
                       int pcol = lofs % prev_ncol;
                       prow = MOD (p + prow, prev_total_rows);
-                      // we only adjust the cursor _row_, as this seems to upset
+                      // we only adjust the cursor _row_ and put it into
+                      // the topmost line of "long line" it was in, as
-                      // applications/shells/readline least.
+                      // this seems to upset applications/shells/readline
+                      // least.
                       if (prow == ocur.row)
-                        screen.cur.row = qrow - (total_rows - nrow);
+                        screen.cur.row = q - (total_rows - nrow);
                       line_t &pline = old_buf [prow];
                       int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
                       lofs += len;
                       qcol += len;
                     }
                 }
-              qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1;
+              qline->l = llen ? MOD (llen - 1, ncol) + 1 : 0;
+              qline->is_longer (0);
               scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
             }
+          while (p != pend && q > 0);
           term_start = total_rows - nrow;
-          view_start = 0;
           nsaved = term_start - q;
           // make sure all terminal lines exist
           while (nsaved < 0)
             scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE);
         }
       else
         {
           // if no scrollback exists (yet), wing, instead of wrap
             {
               row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
             }
           term_start = 0;
-          view_start = 0;
         }
-#ifdef DEBUG_STRICT
+#ifdef DEBUG_STRICT //TODO: remove
       for (int i = -nsaved; i < nrow; i++)
         assert (ROW (i).t);
 #endif
       free (old_buf);
   for (int col = ncol; col--; )
     tabs [col] = col % TABSIZE == 0;
   tt_winch ();
+  HOOK_INVOKE ((this, HOOK_RESET, DT_END));
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Free everything.  That way malloc debugging can find leakage.
   delete ralloc; ralloc = 0;
   free (row_buf);
   free (swap_buf);
   free (drawn_buf);
-  free (temp_buf);
   free (tabs);
   row_buf = 0; // signal that we freed all the arrays
 }
   screen.cur.row = clamp (screen.cur.row, 0, prev_nrow - 1);
   screen.cur.col = clamp (screen.cur.col, 0, prev_ncol - 1);
 #if NSCREENS
-  if (options & Opt_secondaryScreen)
+  if (OPTION (Opt_secondaryScreen))
     {
       num_scr = 0;
       for (int i = prev_nrow; i--; )
         ::swap (ROW(i), swap_buf [i]);
       screen.flags |= Screen_VisibleCursor;
       swap.flags |= Screen_VisibleCursor;
     }
   else
 #endif
-    if (options & Opt_secondaryScroll)
+    if (OPTION (Opt_secondaryScroll))
       scr_scroll_text (0, prev_nrow - 1, prev_nrow);
   return scrn;
 }
   num_scr += count;
   if (count > 0
       && row1 == 0
       && row2 == nrow - 1
-      && (current_screen == PRIMARY || options & Opt_secondaryScroll))
+      && (current_screen == PRIMARY || OPTION (Opt_secondaryScroll)))
     {
       nsaved = min (nsaved + count, saveLines);
+      HOOK_INVOKE ((this, HOOK_SCROLL_BACK, DT_INT, count, DT_INT, nsaved, DT_END));
       term_start = (term_start + count) % total_rows;
       if (selection.op && current_screen == selection.screen)
         {
           selection.beg.row  -= count;
           selection.end.row  -= count;
           selection.mark.row -= count;
-          selection_check (0);
+          if (selection.beg.row < -nsaved
+              || selection.end.row < -nsaved
+              || selection.mark.row < -nsaved)
+            {
+              CLEAR_ALL_SELECTION ();
+              selection.op = SELECTION_CLEAR;
+            }
         }
       for (int i = count; i--; )
-        scr_blank_screen_mem (ROW(row2 - i), rstyle);
+        {
+          // basically thi is a slightly optimized scr_blank_screen_mem
+          // it is worth the effort on slower machines
+          line_t &l = ROW(row2 - i);
+          scr_blank_line (l, 0, l.l, rstyle);
+          l.l = 0;
+          l.f = 0;
+        }
-      if ((options & Opt_scrollWithBuffer)
+      if (OPTION (Opt_scrollWithBuffer)
           && view_start != 0
           && view_start != saveLines)
         scr_page (UP, count);
     }
   else
     {
       if (selection.op && current_screen == selection.screen)
         {
-          int i = selection.beg.row;
+          if ((selection.beg.row < row1 && selection.end.row > row1)
-          int j = selection.end.row;
+              || (selection.beg.row < row2 && selection.end.row > row2)
-          if ((i < row1 && j > row1)
-              || (i < row2 && j > row2)
-              || (i - count < row1 && i >= row1)
+              || (selection.beg.row - count < row1 && selection.beg.row >= row1)
-              || (i - count > row2 && i <= row2)
+              || (selection.beg.row - count > row2 && selection.beg.row <= row2)
-              || (j - count < row1 && j >= row1)
+              || (selection.end.row - count < row1 && selection.end.row >= row1)
-              || (j - count > row2 && j <= row2))
+              || (selection.end.row - count > row2 && selection.end.row <= row2))
             {
               CLEAR_ALL_SELECTION ();
-              selection.op = SELECTION_CLEAR;  /* XXX: too aggressive? */
+              selection.op = SELECTION_CLEAR;
             }
-          else if (j >= row1 && j <= row2)
+          else if (selection.end.row >= row1 && selection.end.row <= row2)
             {
               /* move selected region too */
               selection.beg.row  -= count;
               selection.end.row  -= count;
               selection.mark.row -= count;
       int rows = row2 - row1 + 1;
       min_it (count, rows);
+      line_t *temp_buf = row_buf + total_rows;
       for (int row = 0; row < rows; row++)
         {
           temp_buf [row] = ROW(row1 + (row + count + rows) % rows);
           if (!IN_RANGE_EXC (row + count, 0, rows))
 /* ------------------------------------------------------------------------- */
 /*
  * Add text given in <str> of length <len> to screen struct
  */
 void
-rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
+rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines)
 {
   if (len <= 0)               /* sanity */
     return;
   unsigned char checksel;
   unicode_t c;
-  int row, last_col;
+  int ncol = this->ncol;
-  const unicode_t *strend = str + len;
+  const wchar_t *strend = str + len;
   want_refresh = 1;
   ZERO_SCROLLBACK ();
-  last_col = ncol;
-  if (nlines > 0)
+  if (minlines > 0)
     {
-      nlines += screen.cur.row - screen.bscroll;
+      minlines += screen.cur.row - screen.bscroll;
-      if (nlines > 0
+      if (minlines > 0
           && screen.tscroll == 0
-          && screen.bscroll == (nrow - 1))
+          && screen.bscroll == nrow - 1)
         {
           /* _at least_ this many lines need to be scrolled */
-          scr_scroll_text (screen.tscroll, screen.bscroll, nlines);
+          scr_scroll_text (screen.tscroll, screen.bscroll, minlines);
-          screen.cur.row -= nlines;
+          screen.cur.row -= minlines;
         }
     }
 #ifdef DEBUG_STRICT
-  assert (screen.cur.col < last_col);
+  assert (screen.cur.col < ncol);
   assert (screen.cur.row < nrow
           && screen.cur.row >= -nsaved);
 #endif
-  row = screen.cur.row;
+  int row = screen.cur.row;
   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
   line_t *line = &ROW(row);
   while (str < strend)
     {
-      c = *str++;
+      c = (unicode_t)*str++; // convert to rxvt-unicodes representation
       if (c < 0x20)
         if (c == C0_LF)
           {
-            if (!line->is_longer ())      /* XXX: think about this */
-              max_it (line->l, screen.cur.col);
+            max_it (line->l, screen.cur.col);
             screen.flags &= ~Screen_WrapNext;
             if (screen.cur.row == screen.bscroll)
               scr_scroll_text (screen.tscroll, screen.bscroll, 1);
             line = &ROW(row);  /* _must_ refresh */
             continue;
           }
         else if (c == C0_CR)
           {
-            if (!line->is_longer ())      /* XXX: think about this */
-              max_it (line->l, screen.cur.col);
+            max_it (line->l, screen.cur.col);
             screen.flags &= ~Screen_WrapNext;
             screen.cur.col = 0;
             continue;
           }
           CLEAR_SELECTION ();
         }
       if (screen.flags & Screen_WrapNext)
         {
+          max_it (line->l, ncol);
-          line->set_is_longer ();
+          line->is_longer (1);
           scr_do_wrap ();
           row = screen.cur.row;
           line = &ROW(row);   /* _must_ refresh */
       // do wcwidth before further replacements, as wcwidth might return -1
       // for the line drawing characters below as they might be invalid in the current
       // locale.
       int width = c < 0x100 ? 1 : wcwidth (c);
-      if (charsets[screen.charset] == '0') // DEC SPECIAL
+      if (charsets [screen.charset] == '0') // DEC SPECIAL
         {
           // vt100 special graphics and line drawing
           // 5f-7e standard vt100
           // 40-5e rxvt extension for extra curses acs chars
           static uint16_t vt100_0[62] = { // 41 .. 7e
             }
           rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
           // if the character doesn't fit into the remaining columns...
-          if (screen.cur.col > last_col - width && last_col >= width)
+          if (screen.cur.col > ncol - width && ncol >= width)
             {
               // ...output spaces
               c = ' ';
               // and try the same character next loop iteration
               --str;
             }
+          line->touch ();
           do
             {
               line->t[screen.cur.col] = c;
               line->r[screen.cur.col] = rend;
-              if (screen.cur.col < last_col - 1)
+              if (screen.cur.col < ncol - 1)
                 screen.cur.col++;
               else
                 {
-                  line->l = last_col;
+                  line->l = ncol;
                   if (screen.flags & Screen_Autowrap)
                     screen.flags |= Screen_WrapNext;
                   break;
                 }
             }
           while (--width > 0);
           // pad with spaces when overwriting wide character with smaller one
           if (!width)
+            {
+              line->touch ();
-            for (int c = screen.cur.col; c < last_col && line->t[c] == NOCHAR; c++)
+              for (int c = screen.cur.col; c < ncol && line->t[c] == NOCHAR; c++)
-              {
+                {
-                line->t[c] = ' ';
+                  line->t[c] = ' ';
-                line->r[c] = rend;
+                  line->r[c] = rend;
-              }
+                }
+            }
         }
       else // width == 0
         {
 #if ENABLE_COMBINING
           // handle combining characters
           // we just tag the accent on the previous on-screen character.
           // this is arguably not correct, but also arguably not wrong.
           // we don't handle double-width characters nicely yet.
+          line_t *linep;
           text_t *tp;
           rend_t *rp;
           if (screen.cur.col > 0)
             {
+              linep = line;
               tp = line->t + screen.cur.col - 1;
               rp = line->r + screen.cur.col - 1;
-              while (*tp == NOCHAR && tp > line->t)
-                tp--, rp--;
             }
           else if (screen.cur.row > 0
                    && ROW(screen.cur.row - 1).is_longer ())
             {
-              line_t *line = &ROW(screen.cur.row - 1);
+              linep = &ROW(screen.cur.row - 1);
-              tp = line->t + last_col - 1;
+              tp = line->t + ncol - 1;
-              rp = line->r + last_col - 1;
+              rp = line->r + ncol - 1;
-              while (*tp == NOCHAR && tp > line->t)
-                tp--, rp--;
             }
           else
             continue;
+          linep->touch ();
+          while (*tp == NOCHAR && tp > linep->t)
+            tp--, rp--;
           // first try to find a precomposed character
           unicode_t n = rxvt_compose (*tp, c);
           if (n == NOCHAR)
             n = rxvt_composite.compose (*tp, c);
           *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
 #endif
         }
     }
-  if (!line->is_longer ())      /* XXX: think about this */
-    max_it (line->l, screen.cur.col);
+  max_it (line->l, screen.cur.col);
 #ifdef DEBUG_STRICT
   assert (screen.cur.row >= 0);
 #endif
 }
   if (count == 0)
     return;
   else if (count > 0)
     {
-      int row = screen.cur.row;
-      line_t &l = ROW(row);
+      line_t &l = ROW(screen.cur.row);
       rend_t base_rend = l.r[i];
       ht &= l.t[i] == ' ';
       for (; ++i < ncol; )
         if (tabs[i])
           {
             x = i;
             if (!--count)
               break;
           }
         else
           ht &= l.t[i] == ' '
       if (count)
         x = ncol - 1;
       // store horizontal tab commands as characters inside the text
       // buffer so they can be selected and pasted.
-      if (ht && options & Opt_pastableTabs)
+      if (ht && OPTION (Opt_pastableTabs))
         {
           base_rend = SET_FONT (base_rend, 0);
-          if (!l.is_longer ())      /* XXX: think about this */
+          l.touch (x);
-            max_it (l.l, x);
           i = screen.cur.col;
           l.t[i] = '\t';
           l.r[i] = base_rend;
  */
 #if ENABLE_FRILLS
 void
 rxvt_term::scr_forwardindex ()
 {
-  int row;
   if (screen.cur.col < ncol - 1)
     scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
   else
     {
-      row = screen.cur.row;
+      line_t &l = ROW(screen.cur.row);
-      if (ROW(row).is_longer ()) //TODO//FIXME//LEN
+      l.touch ();
-        ROW(row).l = ncol;
+      l.is_longer (0);
       scr_gotorc (0, 0, R_RELATIVE);
       scr_insdel_chars (1, DELETE);
       scr_gotorc (0, ncol - 1, R_RELATIVE);
     }
  * XTERM_SEQ: Clear whole line   : ESC [ 2 K
  */
 void
 rxvt_term::scr_erase_line (int mode)
 {
-  unsigned int row, col, num;
+  unsigned int col, num;
   want_refresh = 1;
   ZERO_SCROLLBACK ();
   selection_check (1);
-  row = screen.cur.row;
+  line_t &line = ROW(screen.cur.row);
+  line.touch ();
+  line.is_longer (0);
   switch (mode)
     {
       case 0:                     /* erase to end of line */
         col = screen.cur.col;
         num = ncol - col;
-        min_it (ROW(row).l, col);
+        min_it (line.l, col);
         if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
             || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
           CLEAR_SELECTION ();
         break;
       case 1:                     /* erase to beginning of line */
           CLEAR_SELECTION ();
         break;
       case 2:                     /* erase whole line */
         col = 0;
         num = ncol;
-        ROW(row).l = 0;
+        line.l = 0;
         if (selection.beg.row <= screen.cur.row
             && selection.end.row >= screen.cur.row)
           CLEAR_SELECTION ();
         break;
       default:
         return;
     }
-  scr_blank_line (ROW(row), col, num, rstyle);
+  scr_blank_line (line, col, num, rstyle);
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Erase part of whole of the screen
       CLEAR_ROWS (row, num);
     }
   else
     {
       ren = rstyle & (RS_fgMask | RS_bgMask);
-      gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
+      gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
       XChangeGC (display->display, gc, GCForeground, &gcvalue);
       ERASE_ROWS (row, num);
       gcvalue.foreground = pix_colors[Color_fg];
       XChangeGC (display->display, gc, GCForeground, &gcvalue);
     }
   for (; num--; row++)
     {
-      scr_blank_screen_mem (ROW (row), rstyle);
+      scr_blank_screen_mem (ROW(row), rstyle);
-      ROW (row).l = 0;
       scr_blank_line (drawn_buf [row], 0, ncol, ren);
     }
 }
 #if ENABLE_FRILLS
       rend_t *r1 = line.r;
       for (int j = ncol; j--; )
         *r1++ = fs;
-      line.l = ncol;    /* make the `E's selectable */
+      line.is_longer (0);
+      line.touch (ncol);
     }
 }
 /* ------------------------------------------------------------------------- */
 /*
   min_it (count, ncol - screen.cur.col);
   row = screen.cur.row;
   line_t *line = &ROW(row);
+  line->touch ();
+  line->is_longer (0);
   switch (insdel)
     {
       case INSERT:
         for (col = ncol - 1; (col - count) >= screen.cur.col; col--)
           {
             line->t[col] = line->t[col - count];
             line->r[col] = line->r[col - count];
           }
-        if (!line->is_longer ())
+        line->l = min (line->l + count, ncol);
-          {
-            line->l += count;
-            min_it (line->l, ncol);
-          }
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
             if (selection.end.row != screen.cur.row
       case ERASE:
         screen.cur.col += count;     /* don't worry if > ncol */
         selection_check (1);
         screen.cur.col -= count;
+        line->l = max (line->l - count, 0);
         scr_blank_line (*line, screen.cur.col, count, rstyle);
         break;
       case DELETE:
         tr = line->r[ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
           {
             line->t[col] = line->t[col + count];
             line->r[col] = line->r[col + count];
           }
+        line->l = max (line->l - count, 0);
         scr_blank_line (*line, ncol - count, count, tr);
-        if (line->is_longer ()) /* break line continuation */
-          line->l = ncol;
-        line->l = max (line->l - count, 0);
         if (selection.op && current_screen == selection.screen
             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
           {
             if (selection.end.row != screen.cur.row
 rxvt_term::scr_set_tab (int mode)
 {
   if (mode < 0)
     memset (tabs, 0, ncol * sizeof (char));
   else if (screen.cur.col < ncol)
-    tabs[screen.cur.col] = (mode ? 1 : 0);
+    tabs [screen.cur.col] = !!mode;
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Set reverse/normal video
       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
 #if XPM_BACKGROUND
       if (bgPixmap.pixmap == None)
 #endif
 #if TRANSPARENT
-        if (! (options & Opt_transparent) || am_transparent == 0)
+        if (! OPTION (Opt_transparent) || am_transparent == 0)
 #endif
           XSetWindowBackground (display->display, vt,
                                pix_colors[Color_bg]);
       gcvalue.foreground = pix_colors[Color_fg];
  * Set font style
  */
 void
 rxvt_term::set_font_style ()
 {
+#if 0
-  switch (charsets[screen.charset])
+  switch (charsets [screen.charset])
     {
       case '0':                   /* DEC Special Character & Line Drawing Set */
         break;
       case 'A':                   /* United Kingdom (UK) */
         break;
       case 'C':                   /* Finnish character set */
         break;
       case 'K':                   /* German character set */
         break;
     }
+#endif
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Choose a font
 int
 rxvt_term::scr_changeview (unsigned int oldviewstart)
 {
   if (view_start != oldviewstart)
     {
+      HOOK_INVOKE ((this, HOOK_VIEW_CHANGE, DT_INT, view_start, DT_END));
       want_refresh = 1;
       num_scr -= (view_start - oldviewstart);
     }
-  return (int) (view_start - oldviewstart);
+  return (int)view_start - (int)oldviewstart;
 }
 /* ------------------------------------------------------------------------- */
 void
 rxvt_term::scr_bell ()
 {
 #ifndef NO_BELL
 # ifndef NO_MAPALERT
 #  ifdef MAPALERT_OPTION
-  if (options & Opt_mapAlert)
+  if (OPTION (Opt_mapAlert))
 #  endif
     XMapWindow (display->display, parent[0]);
 # endif
-  if (options & Opt_visualBell)
+  if (OPTION (Opt_visualBell))
     {
       scr_rvideo_mode (!rvideo); /* refresh also done */
+      display->flush ();
       rxvt_usleep (VISUAL_BELL_DURATION);
       scr_rvideo_mode (!rvideo); /* refresh also done */
     }
   else
     XBell (display->display, 0);
 #if XPM_BACKGROUND
   must_clear |= bgPixmap.pixmap != None;
 #endif
 #if TRANSPARENT
-  must_clear |= (options & Opt_transparent) && am_transparent;
+  must_clear |= OPTION (Opt_transparent) && am_transparent;
 #endif
   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
   /*
    * B: reverse any characters which are selected
         crp = &ROW(screen.cur.row).r[col];
         if (showcursor && focus)
           {
-            if (options & Opt_cursorUnderline)
+            if (OPTION (Opt_cursorUnderline))
               *crp ^= RS_Uline;
             else
               {
                 *crp ^= RS_RVid;
                 cc1 = *crp & (RS_fgMask | RS_bgMask);
                 if (ISSET_PIXCOLOR (Color_cursor))
                   ccol1 = Color_cursor;
                 else
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-                  ccol1 = GET_FGCOLOR (rstyle);
+                  ccol1 = fgcolor_of (rstyle);
 #else
                   ccol1 = Color_fg;
 #endif
                 if (ISSET_PIXCOLOR (Color_cursor2))
                   ccol2 = Color_cursor2;
                 else
 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
-                  ccol2 = GET_BGCOLOR (rstyle);
+                  ccol2 = bgcolor_of (rstyle);
 #else
                   ccol2 = Color_bg;
 #endif
                 *crp = SET_FGCOLOR (*crp, ccol1);
                 *crp = SET_BGCOLOR (*crp, ccol2);
             oldcursor.col = screen.cur.col;
           }
       }
   }
+  HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
 #if ENABLE_OVERLAY
   scr_swap_overlay ();
 #endif
 #ifndef NO_SLOW_LINK_SUPPORT
               if (wlen < len)
                 ::swap (wlen, len);
               XCopyArea (display->display, vt, vt,
                          gc, 0, Row2Pixel (len + i),
-                         (unsigned int)TermWin_TotalWidth (),
+                         (unsigned int)this->width,
                          (unsigned int)Height2Pixel (wlen - len + 1),
                          0, Row2Pixel (len));
               len = -1;
             }
         }
             count++, i--;
           /*
            * Determine the attributes for the string
            */
-          int fore = GET_FGCOLOR (rend); // desired foreground
+          int fore = fgcolor_of (rend); // desired foreground
-          int back = GET_BGCOLOR (rend); // desired background
+          int back = bgcolor_of (rend); // desired background
-          // only do special processing if any attributes are set, which is rare
+          // only do special processing if any attributes are set, which is unlikely
           if (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful))
             {
 #if ENABLE_STYLES
               // force redraw after "careful" characters to avoid pixel droppings
               if (srp[col] & RS_Careful && col < ncol - 1 && 0)
     }                         /* for (row....) */
 #if ENABLE_OVERLAY
   scr_swap_overlay ();
 #endif
+  HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
   /*
    * G: cleanup cursor and display outline cursor if necessary
    */
   if (showcursor)
     {
       if (focus)
         {
-          if (options & Opt_cursorUnderline)
+          if (OPTION (Opt_cursorUnderline))
             *crp ^= RS_Uline;
           else
             {
               *crp ^= RS_RVid;
 #ifndef NO_CURSORCOLOR
   num_scr = 0;
   num_scr_allow = 1;
 }
 void
-rxvt_term::scr_remap_chars (const line_t &l)
+rxvt_term::scr_remap_chars (line_t &l)
 {
   if (!l.t)
     return;
+  l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
   for (int i = ncol; i--; )
     l.r[i] = SET_FONT (l.r[i], FONTSET (l.r[i])->find_font (l.t[i]));
 }
   if (really)
     XClearWindow (display->display, vt);
 }
+void
+rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle1, rend_t rstyle2)
+{
+  int view_end = -view_start + nrow;
+  int row, col;
+  for (row = max (beg_row, -view_start); row <= min (end_row, view_end); row++)
+    {
+      text_t *stp = ROW(row).t;
+      rend_t *srp = ROW(row).r;
+      for (col = beg_col; col < end_col; col++)
+        srp[col] ^= rstyle1;
+      while (col-- > beg_col && (stp[col] == NOCHAR || unicode::is_space (stp[col])))
+        srp[col] ^= rstyle2;
+      if (++col < end_col)
+        srp[col] ^= rstyle2;
+    }
+}
+void
+rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle)
+{
+  int view_end = -view_start + nrow;
+  int row, col;
+  if (beg_row >= -view_start)
+    {
+      col = beg_col;
+      row = beg_row;
+    }
+  else
+    {
+      col = 0;
+      row = -view_start;
+    }
+  for (; row < min (end_row, view_end); row++, col = 0)
+    for (rend_t *srp = ROW(row).r; col < ncol; col++)
+      srp[col] ^= rstyle;
+  if (row == end_row)
+    for (rend_t *srp = ROW(row).r; col < end_col; col++)
+      srp[col] ^= rstyle;
+}
 /* ------------------------------------------------------------------------- */
 void
 rxvt_term::scr_reverse_selection ()
 {
   if (selection.op
       && current_screen == selection.screen
       && selection.end.row >= -view_start)
     {
-      int view_end = -view_start + nrow;
-      int row, col;
 #if ENABLE_FRILLS
       if (selection.rect)
-        {
+        scr_xor_rect (selection.beg.row, selection.beg.col,
-          for (row = max (selection.beg.row, -view_start); row <= min (selection.end.row, view_end); row++)
+                      selection.end.row, selection.end.col,
-            for (rend_t *srp = ROW(row).r, col = selection.beg.col; col < selection.end.col; col++)
+                      RS_RVid, RS_RVid | RS_Uline);
-              srp[col] ^= RS_RVid;
-        }
       else
 #endif
-        {
+        scr_xor_span (selection.beg.row, selection.beg.col,
-          if (selection.beg.row >= -view_start)
+                      selection.end.row, selection.end.col,
-            {
+                      RS_RVid);
-              col = selection.beg.col;
-              row = selection.beg.row;
-            }
-          else
-            {
-              col = 0;
-              row = view_start;
-            }
-          for (; row < min (selection.end.row, view_end); row++, col = 0)
-            for (rend_t *srp = ROW(row).r; col < ncol; col++)
-              srp[col] ^= RS_RVid;
-          if (row == selection.end.row)
-            for (rend_t *srp = ROW(row).r; col < selection.end.col; col++)
-              srp[col] ^= RS_RVid;
-        }
     }
 }
 /* ------------------------------------------------------------------------- */
 /*
 /* ------------------------------------------------------------------------- */
 /*
  * Paste a selection direct to the command fd
  */
 void
-rxvt_term::paste (unsigned char *data, unsigned int len)
+rxvt_term::paste (char *data, unsigned int len)
 {
   /* convert normal newline chars into common keyboard Return key sequence */
   for (unsigned int i = 0; i < len; i++)
     if (data[i] == C0_LF)
       data[i] = C0_CR;
     {
       wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
       char *s = rxvt_wcstombs (w);
       free (w);
       // TODO: strlen == only the first element will be converted. well...
-      paste ((unsigned char *)s, strlen (s));
+      paste (s, strlen (s));
       free (s);
     }
   else
 #endif
   if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
       && cl)
     {
       for (int i = 0; i < cr; i++)
-        paste ((unsigned char *)cl[i], strlen (cl[i]));
+        paste (cl[i], strlen (cl[i]));
       XFreeStringList (cl);
     }
   else
-    paste (ct.value, ct.nitems); // paste raw
+    paste ((char *)ct.value, ct.nitems); // paste raw
 bailout:
   XFree (ct.value);
   if (selection_wait == Sel_normal)
     return;                 /* outside window */
   if (selection.text)
     { /* internal selection */
       char *str = rxvt_wcstombs (selection.text, selection.len);
-      paste ((unsigned char *)str, strlen (str));
+      paste (str, strlen (str));
       free (str);
       return;
     }
   else
     {
   selection.op = SELECTION_DONE;
   if (selection.clicks == 4)
     return;                 /* nothing selected, go away */
+  if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
+    return;
   i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
   new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
   int ofs = 0;
   int extra = 0;
           col = selection.beg.col;
           end_col = ncol + 1;
         }
       else
 #endif
-        end_col = ROW(row).is_longer () ? ncol : ROW(row).l; //TODO//FIXME//LEN
+        end_col = ROW(row).l;
       col = max (col, 0);
-      if (row == selection.end.row || selection.rect)
+      if (row == selection.end.row
+#if ENABLE_FRILLS
+          || selection.rect
+#endif
+          )
-        end_col = min (end_col, selection.end.col);
+        min_it (end_col, selection.end.col);
       t = ROW(row).t + col;
       for (; col < end_col; col++)
         {
           if (*t == NOCHAR)
             t++;
 #if ENABLE_COMBINING
 #endif
           else
             new_selection_text[ofs++] = *t++;
         }
+#if ENABLE_FRILLS
+      if (selection.rect)
+        {
+          while (ofs
+                 && new_selection_text[ofs - 1] != C0_LF
+                 && unicode::is_space (new_selection_text[ofs - 1]))
+            --ofs;
+          new_selection_text[ofs++] = C0_LF;
+        }
+      else
+#endif
-      if (!ROW(row).is_longer () && row != selection.end.row)
+        if (!ROW(row).is_longer () && row != selection.end.row)
-        new_selection_text[ofs++] = C0_LF;
+          new_selection_text[ofs++] = C0_LF;
     }
   if (end_col != selection.end.col)
     new_selection_text[ofs++] = C0_LF;
   // we usually allocate much more than necessary, so realloc it smaller again
   selection.len = ofs;
   selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
+  if (HOOK_INVOKE ((this, HOOK_SEL_GRAB, DT_LONG, (long)tm, DT_END)))
+    return;
+  selection_grab (tm);
+}
+bool
+rxvt_term::selection_grab (Time tm)
+{
+  selection_time = tm;
   XSetSelectionOwner (display->display, XA_PRIMARY, vt, tm);
   if (XGetSelectionOwner (display->display, XA_PRIMARY) == vt)
+    {
-    display->set_selection_owner (this);
+      display->set_selection_owner (this);
+      return true;
+    }
   else
-    rxvt_warn ("can't get primary selection, ignoring.\n");
+    return false;
 #if 0
   XTextProperty ct;
   if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
     {
       set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
       XFree (ct.value);
     }
 #endif
-  selection_time = tm;
 }
 /* ------------------------------------------------------------------------- */
 /*
  * Mark or select text based upon number of clicks: 1, 2, or 3
             }
         }
       break;
     }
-Old_Word_Selection_You_Die:
   if (dirn == DN)
     col++;                  /* put us on one past the end */
   /* Poke the values back in */
   ret->row = row;
   else if (selection.clicks == 2)
     {
       if (ROWCOL_IS_AFTER (selection.end, selection.beg))
         selection.end.col--;
+      if (!HOOK_INVOKE ((this, HOOK_SEL_EXTEND, DT_END)))
+        {
-      selection_delimit_word (UP, &selection.beg, &selection.beg);
+          selection_delimit_word (UP, &selection.beg, &selection.beg);
-      selection_delimit_word (DN, &selection.end, &selection.end);
+          selection_delimit_word (DN, &selection.end, &selection.end);
+        }
     }
   else if (selection.clicks == 3)
     {
 #if ENABLE_FRILLS
-      if (options & Opt_tripleclickwords)
+      if (OPTION (Opt_tripleclickwords))
         {
           selection_delimit_word (UP, &selection.beg, &selection.beg);
           for (int end_row = selection.mark.row; end_row < nrow; end_row++)
             {
     {
       stp = ROW(end_row).t;
       while (--end_col >= 0)
         {
-          if (stp[end_col] != ' '
+          if (stp[end_col] != NOCHAR
-              && stp[end_col] != '\t'
+              && !unicode::is_space (stp[end_col]))
-              && stp[end_col] != NOCHAR)
             break;
         }
       if (end_col >= 0
           || !ROW(end_row - 1).is_longer ())
 #if ENABLE_OVERLAY
 void
 rxvt_term::scr_overlay_new (int x, int y, int w, int h)
 {
-  if (nrow < 3 || ncol < 3)
+  if (nrow < 1 || ncol < 1)
     return;
   want_refresh = 1;
   scr_overlay_off ();
   for (int y = ov_h; y--; )
     {
       text_t *t1 = ov_text[y];
       rend_t *r1 = ov_rend[y];
-      text_t *t2 = ROW(y - view_start).t + ov_x;
+      text_t *t2 = ROW(y + ov_y - view_start).t + ov_x;
-      rend_t *r2 = ROW(y - view_start).r + ov_x;
+      rend_t *r2 = ROW(y + ov_y - view_start).r + ov_x;
       for (int x = ov_w; x--; )
         {
           text_t t = *t1; *t1++ = *t2; *t2++ = t;
           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, FONTSET (r)->find_font (t));

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/screen.C (file contents): Revision 1.190 by root, Thu Dec 22 15:52:57 2005 UTC vs. Revision 1.220 by root, Mon Jan 9 23:18:49 2006 UTC

Diff Legend

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.190 by root, Thu Dec 22 15:52:57 2005 UTC vs.
Revision 1.220 by root, Mon Jan 9 23:18:49 2006 UTC