ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/screen.C
(Generate patch)

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.59 by pcg, Mon Mar 15 00:08:11 2004 UTC vs.
Revision 1.66 by pcg, Sun Mar 28 02:07:08 2004 UTC

… …
439 uint16_t total_rows; 439 uint16_t total_rows;
440 int i; 440 int i;
441 441
442 total_rows = TermWin.nrow + TermWin.saveLines; 442 total_rows = TermWin.nrow + TermWin.saveLines;
443 443
444#ifdef DEBUG_STRICT
445 for (i = 0; i < total_rows; i++)
446 {
447 if (screen.text[i])
448 /* then so is screen.rend[i] */
449 assert (screen.rend[i]);
450 }
451#endif
452
453 delete talloc; talloc = 0; 444 delete talloc; talloc = 0;
454 delete ralloc; ralloc = 0; 445 delete ralloc; ralloc = 0;
455 446
456 free (screen.text); 447 free (screen.text);
457 free (screen.tlen); 448 free (screen.tlen);
… …
500 * XTERM_SEQ: Restore cursor: ESC 8 491 * XTERM_SEQ: Restore cursor: ESC 8
501 */ 492 */
502void 493void
503rxvt_term::scr_cursor (int mode) 494rxvt_term::scr_cursor (int mode)
504{ 495{
505 screen_t *s; 496 screen_t *s;
506 497
507 D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode)); 498 D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));
508 499
509#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR) 500#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
510 if (current_screen == SECONDARY) 501 if (current_screen == SECONDARY)
511 s = & (swap); 502 s = &swap;
512 else 503 else
513#endif 504#endif
514 s = & (screen); 505 s = &screen;
506
515 switch (mode) 507 switch (mode)
516 { 508 {
517 case SAVE: 509 case SAVE:
518 s->s_cur.row = s->cur.row; 510 s->s_cur.row = s->cur.row;
519 s->s_cur.col = s->cur.col; 511 s->s_cur.col = s->cur.col;
… …
530 s->charset = s->s_charset; 522 s->charset = s->s_charset;
531 charsets[s->charset] = s->s_charset_char; 523 charsets[s->charset] = s->s_charset_char;
532 set_font_style (); 524 set_font_style ();
533 break; 525 break;
534 } 526 }
527
535 /* boundary check in case screen size changed between SAVE and RESTORE */ 528 /* boundary check in case screen size changed between SAVE and RESTORE */
536 MIN_IT (s->cur.row, TermWin.nrow - 1); 529 MIN_IT (s->cur.row, TermWin.nrow - 1);
537 MIN_IT (s->cur.col, TermWin.ncol - 1); 530 MIN_IT (s->cur.col, TermWin.ncol - 1);
538#ifdef DEBUG_STRICT 531#ifdef DEBUG_STRICT
539 assert (s->cur.row >= 0); 532 assert (s->cur.row >= 0);
… …
551 * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l 544 * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
552 */ 545 */
553int 546int
554rxvt_term::scr_change_screen (int scrn) 547rxvt_term::scr_change_screen (int scrn)
555{ 548{
556 int i; 549 int i;
557#if NSCREENS 550#if NSCREENS
558 int offset; 551 int offset;
559#endif 552#endif
560 553
561 want_refresh = 1; 554 want_refresh = 1;
562 555
563 D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn)); 556 D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));
… …
801 MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1); 794 MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
802 MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled); 795 MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
803#endif 796#endif
804 row = screen.cur.row + TermWin.saveLines; 797 row = screen.cur.row + TermWin.saveLines;
805 798
806 checksel = (selection.op 799 checksel = selection.op && current_screen == selection.screen ? 1 : 0;
807 && current_screen == selection.screen) ? 1 : 0;
808 clearsel = 0; 800 clearsel = 0;
809 801
810 stp = screen.text[row]; 802 stp = screen.text[row];
811 srp = screen.rend[row]; 803 srp = screen.rend[row];
812 804
813 for (i = 0; i < len;) 805 while (len--)
814 { 806 {
815 c = str[i++]; 807 c = *str++;
808
809 if (c < 0x20)
816 switch (c) 810 switch (c)
817 { 811 {
818 case '\t': 812 case '\t':
819 scr_tab (1); 813 scr_tab (1);
820 continue; 814 continue;
815
821 case '\n': 816 case '\n':
822 if (screen.tlen[row] != -1) /* XXX: think about this */ 817 if (screen.tlen[row] != -1) /* XXX: think about this */
823 MAX_IT (screen.tlen[row], screen.cur.col); 818 MAX_IT (screen.tlen[row], screen.cur.col);
819
824 screen.flags &= ~Screen_WrapNext; 820 screen.flags &= ~Screen_WrapNext;
821
825 if (screen.cur.row == screen.bscroll) 822 if (screen.cur.row == screen.bscroll)
826 scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0); 823 scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
827 else if (screen.cur.row < (TermWin.nrow - 1)) 824 else if (screen.cur.row < (TermWin.nrow - 1))
828 row = (++screen.cur.row) + TermWin.saveLines; 825 row = (++screen.cur.row) + TermWin.saveLines;
826
829 stp = screen.text[row]; /* _must_ refresh */ 827 stp = screen.text[row]; /* _must_ refresh */
830 srp = screen.rend[row]; /* _must_ refresh */ 828 srp = screen.rend[row]; /* _must_ refresh */
831 continue; 829 continue;
830
832 case '\r': 831 case '\r':
833 if (screen.tlen[row] != -1) /* XXX: think about this */ 832 if (screen.tlen[row] != -1) /* XXX: think about this */
834 MAX_IT (screen.tlen[row], screen.cur.col); 833 MAX_IT (screen.tlen[row], screen.cur.col);
834
835 screen.flags &= ~Screen_WrapNext; 835 screen.flags &= ~Screen_WrapNext;
836 screen.cur.col = 0; 836 screen.cur.col = 0;
837 continue; 837 continue;
838 default:
839 if (c == 127)
840 continue; /* yummmm..... */
841 break;
842 } 838 }
843 839
844 if (checksel /* see if we're writing within selection */ 840 if (checksel /* see if we're writing within selection */
845 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg) 841 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
846 && ROWCOL_IS_BEFORE (screen.cur, selection.end)) 842 && ROWCOL_IS_BEFORE (screen.cur, selection.end))
847 { 843 {
… …
866 if (screen.flags & Screen_Insert) 862 if (screen.flags & Screen_Insert)
867 scr_insdel_chars (1, INSERT); 863 scr_insdel_chars (1, INSERT);
868 864
869 // rely on wcwidth to tell us the character width, at least for non-latin1 865 // rely on wcwidth to tell us the character width, at least for non-latin1
870 // do wcwidth before further replacements, as wcwidth says that line-drawing 866 // do wcwidth before further replacements, as wcwidth says that line-drawing
871 // characters have width -1 (DOH!) on gnu/linux sometimes. 867 // characters have width -1 (DOH!) on GNU/Linux sometimes.
872 int width = c < 256 ? 1 : wcwidth (c); 868 int width = c < 256 ? 1 : wcwidth (c);
873 869
874 if (charsets[screen.charset] == '0') // DEC SPECIAL 870 if (charsets[screen.charset] == '0') // DEC SPECIAL
875 switch (c)
876 { 871 {
877 // vt100 special graphics and line drawing 872 // vt100 special graphics and line drawing
878 case '`': c = 0x25c6; break; case '_': c = 0x0020; break; 873 static uint16_t vt100_0[32] = { // 5f .. 7e
879 case 'a': c = 0x2592; break; case 'b': c = 0x2409; break; case 'c': c = 0x240c; break; 874 0x0020, 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
880 case 'd': c = 0x240d; break; case 'e': c = 0x240a; break; case 'f': c = 0x00b0; break; 875 0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
881 case 'g': c = 0x00b1; break; case 'h': c = 0x2424; break; case 'i': c = 0x240b; break; 876 0x23ba, 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534,
882 case 'j': c = 0x2518; break; case 'k': c = 0x2510; break; case 'l': c = 0x250c; break; 877 0x252c, 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,
883 case 'm': c = 0x2514; break; case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break;
884 case 'p': c = 0x23bb; break; case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break;
885 case 's': c = 0x23bd; break; case 't': c = 0x251c; break; case 'u': c = 0x2524; break;
886 case 'v': c = 0x2534; break; case 'w': c = 0x252c; break; case 'x': c = 0x2502; break;
887 case 'y': c = 0x2264; break; case 'z': c = 0x2265; break; case '{': c = 0x03c0; break;
888 case '|': c = 0x2260; break; case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
889 } 878 };
879
880 if (c >= 0x5f && c <= 0x7e)
881 {
882 c = vt100_0[c - 0x5f];
883 width = 1;
884 }
885 }
890 886
891 if (width > 0) 887 if (width > 0)
892 { 888 {
893#if !UNICODE_3 && ENABLE_COMBINING 889#if !UNICODE_3 && ENABLE_COMBINING
894 // trim characters we can't store directly :( 890 // trim characters we can't store directly :(
… …
1014 * XTERM_SEQ: CTRL-I 1010 * XTERM_SEQ: CTRL-I
1015 */ 1011 */
1016void 1012void
1017rxvt_term::scr_tab (int count) 1013rxvt_term::scr_tab (int count)
1018{ 1014{
1019 int i, x; 1015 int i, x;
1020 1016
1021 D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count)); 1017 D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));
1022 want_refresh = 1; 1018 want_refresh = 1;
1023 i = x = screen.cur.col; 1019 i = x = screen.cur.col;
1020
1024 if (count == 0) 1021 if (count == 0)
1025 return; 1022 return;
1026 else if (count > 0) 1023 else if (count > 0)
1027 { 1024 {
1028 for (; ++i < TermWin.ncol; ) 1025 for (; ++i < TermWin.ncol; )
… …
1030 { 1027 {
1031 x = i; 1028 x = i;
1032 if (!--count) 1029 if (!--count)
1033 break; 1030 break;
1034 } 1031 }
1032
1035 if (count) 1033 if (count)
1036 x = TermWin.ncol - 1; 1034 x = TermWin.ncol - 1;
1037 } 1035 }
1038 else /* if (count < 0) */ 1036 else /* if (count < 0) */
1039 { 1037 {
… …
1042 { 1040 {
1043 x = i; 1041 x = i;
1044 if (!++count) 1042 if (!++count)
1045 break; 1043 break;
1046 } 1044 }
1045
1047 if (count) 1046 if (count)
1048 x = 0; 1047 x = 0;
1049 } 1048 }
1049
1050 if (x != screen.cur.col) 1050 if (x != screen.cur.col)
1051 scr_gotorc (0, x, R_RELATIVE); 1051 scr_gotorc (0, x, R_RELATIVE);
1052} 1052}
1053 1053
1054/* ------------------------------------------------------------------------- */ 1054/* ------------------------------------------------------------------------- */
… …
1247 * XTERM_SEQ: Clear whole screen : ESC [ 2 J 1247 * XTERM_SEQ: Clear whole screen : ESC [ 2 J
1248 */ 1248 */
1249void 1249void
1250rxvt_term::scr_erase_screen (int mode) 1250rxvt_term::scr_erase_screen (int mode)
1251{ 1251{
1252 int num; 1252 int num;
1253 int32_t row, row_offset; 1253 int32_t row, row_offset;
1254 rend_t ren; 1254 rend_t ren;
1255 XGCValues gcvalue; 1255 XGCValues gcvalue;
1256 1256
1257 want_refresh = 1; 1257 want_refresh = 1;
1258 D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row)); 1258 D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));
1259 ZERO_SCROLLBACK (); 1259 ZERO_SCROLLBACK ();
1260 row_offset = (int32_t)TermWin.saveLines; 1260 row_offset = (int32_t)TermWin.saveLines;
… …
1279 num = TermWin.nrow; 1279 num = TermWin.nrow;
1280 break; 1280 break;
1281 default: 1281 default:
1282 return; 1282 return;
1283 } 1283 }
1284
1284 refresh_type |= REFRESH_BOUNDS; 1285 refresh_type |= REFRESH_BOUNDS;
1286
1285 if (selection.op && current_screen == selection.screen 1287 if (selection.op && current_screen == selection.screen
1286 && ((selection.beg.row >= row && selection.beg.row <= row + num) 1288 && ((selection.beg.row >= row && selection.beg.row <= row + num)
1287 || (selection.end.row >= row 1289 || (selection.end.row >= row
1288 && selection.end.row <= row + num))) 1290 && selection.end.row <= row + num)))
1289 CLEAR_SELECTION (); 1291 CLEAR_SELECTION ();
1292
1290 if (row >= TermWin.nrow) /* Out Of Bounds */ 1293 if (row >= TermWin.nrow) /* Out Of Bounds */
1291 return; 1294 return;
1295
1292 MIN_IT (num, (TermWin.nrow - row)); 1296 MIN_IT (num, (TermWin.nrow - row));
1297
1293 if (rstyle & (RS_RVid | RS_Uline)) 1298 if (rstyle & (RS_RVid | RS_Uline))
1294 ren = (rend_t) ~RS_None; 1299 ren = (rend_t) ~RS_None;
1295 else if (GET_BASEBG (rstyle) == Color_bg) 1300 else if (GET_BASEBG (rstyle) == Color_bg)
1296 { 1301 {
1297 ren = DEFAULT_RSTYLE; 1302 ren = DEFAULT_RSTYLE;
… …
1304 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue); 1309 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1305 ERASE_ROWS (row, num); 1310 ERASE_ROWS (row, num);
1306 gcvalue.foreground = PixColors[Color_fg]; 1311 gcvalue.foreground = PixColors[Color_fg];
1307 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue); 1312 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1308 } 1313 }
1314
1309 for (; num--; row++) 1315 for (; num--; row++)
1310 { 1316 {
1311 scr_blank_screen_mem (screen.text, screen.rend, 1317 scr_blank_screen_mem (screen.text, screen.rend,
1312 (unsigned int) (row + row_offset), rstyle); 1318 (unsigned int) (row + row_offset), rstyle);
1313 screen.tlen[row + row_offset] = 0; 1319 screen.tlen[row + row_offset] = 0;
… …
1347 * Insert/Delete <count> lines 1353 * Insert/Delete <count> lines
1348 */ 1354 */
1349void 1355void
1350rxvt_term::scr_insdel_lines (int count, int insdel) 1356rxvt_term::scr_insdel_lines (int count, int insdel)
1351{ 1357{
1352 int end; 1358 int end;
1353 1359
1354 ZERO_SCROLLBACK (); 1360 ZERO_SCROLLBACK ();
1355 1361
1356 selection_check (1); 1362 selection_check (1);
1357 1363
… …
1376 * Insert/Delete <count> characters from the current position 1382 * Insert/Delete <count> characters from the current position
1377 */ 1383 */
1378void 1384void
1379rxvt_term::scr_insdel_chars (int count, int insdel) 1385rxvt_term::scr_insdel_chars (int count, int insdel)
1380{ 1386{
1381 int col, row; 1387 int col, row;
1382 rend_t tr; 1388 rend_t tr;
1383 text_t *stp; 1389 text_t *stp;
1384 rend_t *srp; 1390 rend_t *srp;
1385 int16_t *slp; 1391 int16_t *slp;
1386 1392
1387 want_refresh = 1; 1393 want_refresh = 1;
1388 ZERO_SCROLLBACK (); 1394 ZERO_SCROLLBACK ();
1389 1395
1390 if (count <= 0) 1396 if (count <= 0)
… …
1397 screen.flags &= ~Screen_WrapNext; 1403 screen.flags &= ~Screen_WrapNext;
1398 1404
1399 stp = screen.text[row]; 1405 stp = screen.text[row];
1400 srp = screen.rend[row]; 1406 srp = screen.rend[row];
1401 slp = & (screen.tlen[row]); 1407 slp = & (screen.tlen[row]);
1408
1402 switch (insdel) 1409 switch (insdel)
1403 { 1410 {
1404 case INSERT: 1411 case INSERT:
1405 for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col; 1412 for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
1406 col--) 1413 col--)
1407 { 1414 {
1408 stp[col] = stp[col - count]; 1415 stp[col] = stp[col - count];
1409 srp[col] = srp[col - count]; 1416 srp[col] = srp[col - count];
1410 } 1417 }
1418
1411 if (*slp != -1) 1419 if (*slp != -1)
1412 { 1420 {
1413 *slp += count; 1421 *slp += count;
1414 MIN_IT (*slp, TermWin.ncol); 1422 MIN_IT (*slp, TermWin.ncol);
1415 } 1423 }
1424
1416 if (selection.op && current_screen == selection.screen 1425 if (selection.op && current_screen == selection.screen
1417 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)) 1426 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1418 { 1427 {
1419 if (selection.end.row != screen.cur.row 1428 if (selection.end.row != screen.cur.row
1420 || (selection.end.col + count >= TermWin.ncol)) 1429 || (selection.end.col + count >= TermWin.ncol))
… …
1424 selection.beg.col += count; 1433 selection.beg.col += count;
1425 selection.mark.col += count; /* XXX: yes? */ 1434 selection.mark.col += count; /* XXX: yes? */
1426 selection.end.col += count; 1435 selection.end.col += count;
1427 } 1436 }
1428 } 1437 }
1438
1429 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]), 1439 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1430 (unsigned int)count, rstyle); 1440 (unsigned int)count, rstyle);
1431 break; 1441 break;
1442
1432 case ERASE: 1443 case ERASE:
1433 screen.cur.col += count; /* don't worry if > TermWin.ncol */ 1444 screen.cur.col += count; /* don't worry if > TermWin.ncol */
1434 selection_check (1); 1445 selection_check (1);
1435 screen.cur.col -= count; 1446 screen.cur.col -= count;
1436 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]), 1447 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1437 (unsigned int)count, rstyle); 1448 (unsigned int)count, rstyle);
1438 break; 1449 break;
1450
1439 case DELETE: 1451 case DELETE:
1440 tr = srp[TermWin.ncol - 1]
1441 & (RS_fgMask | RS_bgMask | RS_baseattrMask); 1452 tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
1453
1442 for (col = screen.cur.col; (col + count) < TermWin.ncol; col++) 1454 for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
1443 { 1455 {
1444 stp[col] = stp[col + count]; 1456 stp[col] = stp[col + count];
1445 srp[col] = srp[col + count]; 1457 srp[col] = srp[col + count];
1446 } 1458 }
1459
1447 scr_blank_line (& (stp[TermWin.ncol - count]), 1460 scr_blank_line (& (stp[TermWin.ncol - count]),
1448 & (srp[TermWin.ncol - count]), 1461 & (srp[TermWin.ncol - count]),
1449 (unsigned int)count, tr); 1462 (unsigned int)count, tr);
1463
1450 if (*slp == -1) /* break line continuation */ 1464 if (*slp == -1) /* break line continuation */
1451 *slp = TermWin.ncol; 1465 *slp = TermWin.ncol;
1466
1452 *slp -= count; 1467 *slp -= count;
1453 MAX_IT (*slp, 0); 1468 MAX_IT (*slp, 0);
1469
1454 if (selection.op && current_screen == selection.screen 1470 if (selection.op && current_screen == selection.screen
1455 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)) 1471 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1456 { 1472 {
1457 if (selection.end.row != screen.cur.row 1473 if (selection.end.row != screen.cur.row
1458 || (screen.cur.col >= selection.beg.col - count) 1474 || (screen.cur.col >= selection.beg.col - count)
… …
1464 selection.beg.col -= count; 1480 selection.beg.col -= count;
1465 selection.mark.col -= count; /* XXX: yes? */ 1481 selection.mark.col -= count; /* XXX: yes? */
1466 selection.end.col -= count; 1482 selection.end.col -= count;
1467 } 1483 }
1468 } 1484 }
1485
1469 break; 1486 break;
1470 } 1487 }
1471} 1488}
1472 1489
1473/* ------------------------------------------------------------------------- */ 1490/* ------------------------------------------------------------------------- */
… …
1478void 1495void
1479rxvt_term::scr_scroll_region (int top, int bot) 1496rxvt_term::scr_scroll_region (int top, int bot)
1480{ 1497{
1481 MAX_IT (top, 0); 1498 MAX_IT (top, 0);
1482 MIN_IT (bot, (int)TermWin.nrow - 1); 1499 MIN_IT (bot, (int)TermWin.nrow - 1);
1500
1483 if (top > bot) 1501 if (top > bot)
1484 return; 1502 return;
1503
1485 screen.tscroll = top; 1504 screen.tscroll = top;
1486 screen.bscroll = bot; 1505 screen.bscroll = bot;
1487 scr_gotorc (0, 0, 0); 1506 scr_gotorc (0, 0, 0);
1488} 1507}
1489 1508
… …
1947 1966
1948 /* 1967 /*
1949 * C: set the cursor character (s) 1968 * C: set the cursor character (s)
1950 */ 1969 */
1951 { 1970 {
1952 unsigned char setoldcursor; 1971 unsigned char setoldcursor;
1953 rend_t ccol1, /* Cursor colour */ 1972 rend_t ccol1, /* Cursor colour */
1954 ccol2; /* Cursor colour2 */ 1973 ccol2; /* Cursor colour2 */
1955 1974
1956 showcursor = (screen.flags & Screen_VisibleCursor); 1975 showcursor = (screen.flags & Screen_VisibleCursor);
1957#ifdef CURSOR_BLINK 1976#ifdef CURSOR_BLINK
1958 if (hidden_cursor) 1977 if (hidden_cursor)
1959 showcursor = 0; 1978 showcursor = 0;
1960#endif 1979#endif
1961 1980
1962 if (showcursor) 1981 if (showcursor)
1963 { 1982 {
1964 srp = & (screen.rend[screen.cur.row + TermWin.saveLines] 1983 srp = &(screen.rend[screen.cur.row + TermWin.saveLines][screen.cur.col]);
1965 [screen.cur.col]);
1966 1984
1967 if (showcursor && TermWin.focus) 1985 if (showcursor && TermWin.focus)
1968 { 1986 {
1969 *srp ^= RS_RVid; 1987 *srp ^= RS_RVid;
1970#ifndef NO_CURSORCOLOR 1988#ifndef NO_CURSORCOLOR
… …
1998 if (screen.cur.row + TermWin.view_start != ocrow 2016 if (screen.cur.row + TermWin.view_start != ocrow
1999 || screen.cur.col != oldcursor.col) 2017 || screen.cur.col != oldcursor.col)
2000 { 2018 {
2001 if (ocrow < TermWin.nrow 2019 if (ocrow < TermWin.nrow
2002 && oldcursor.col < TermWin.ncol) 2020 && oldcursor.col < TermWin.ncol)
2003 {
2004 drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline); 2021 drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);
2005 } 2022
2006 if (TermWin.focus || !showcursor) 2023 if (TermWin.focus || !showcursor)
2007 oldcursor.row = -1; 2024 oldcursor.row = -1;
2008 else 2025 else
2009 setoldcursor = 1; 2026 setoldcursor = 1;
2010 } 2027 }
2011 } 2028 }
2012 else if (!TermWin.focus) 2029 else if (!TermWin.focus)
2013 setoldcursor = 1; 2030 setoldcursor = 1;
2031
2014 if (setoldcursor) 2032 if (setoldcursor)
2015 { 2033 {
2016 if (screen.cur.row + TermWin.view_start >= TermWin.nrow) 2034 if (screen.cur.row + TermWin.view_start >= TermWin.nrow)
2017 oldcursor.row = -1; 2035 oldcursor.row = -1;
2018 else 2036 else
… …
2030 */ 2048 */
2031 i = num_scr; 2049 i = num_scr;
2032 if (refresh_type == FAST_REFRESH && num_scr_allow && i 2050 if (refresh_type == FAST_REFRESH && num_scr_allow && i
2033 && abs (i) < TermWin.nrow && !must_clear) 2051 && abs (i) < TermWin.nrow && !must_clear)
2034 { 2052 {
2035 int16_t nits; 2053 int16_t nits;
2036 int j; 2054 int j;
2037 rend_t *drp2; 2055 rend_t *drp2;
2038 text_t *dtp2; 2056 text_t *dtp2;
2039 int len, wlen; 2057 int len, wlen;
2040 2058
2041 j = TermWin.nrow; 2059 j = TermWin.nrow;
2042 wlen = len = -1; 2060 wlen = len = -1;
2043 row = i > 0 ? 0 : j - 1; 2061 row = i > 0 ? 0 : j - 1;
2044 for (; j-- >= 0; row += (i > 0 ? 1 : -1)) 2062 for (; j-- >= 0; row += (i > 0 ? 1 : -1))
… …
2620void 2638void
2621rxvt_term::incr_cb (time_watcher &w) 2639rxvt_term::incr_cb (time_watcher &w)
2622{ 2640{
2623 selection_wait = Sel_none; 2641 selection_wait = Sel_none;
2624 2642
2625 rxvt_print_error ("data loss: timeout on INCR selection paste"); 2643 rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2626} 2644}
2627 2645
2628/* 2646/*
2629 * INCR support originally provided by Paul Sheer <psheer@obsidian.co.za> 2647 * INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2630 */ 2648 */
… …
2709 { 2727 {
2710 int i; 2728 int i;
2711 2729
2712 selection_request_time = tm; 2730 selection_request_time = tm;
2713 selection_wait = Sel_normal; 2731 selection_wait = Sel_normal;
2732
2714 for (i = Sel_Primary; i <= Sel_Clipboard; i++) 2733 for (i = Sel_Primary; i <= Sel_Clipboard; i++)
2715 { 2734 {
2716#if X_HAVE_UTF8_STRING 2735#if X_HAVE_UTF8_STRING
2717 selection_type = Sel_UTF8String; 2736 selection_type = Sel_UTF8String;
2718 if (selection_request_other (xa[XA_UTF8_STRING], i)) 2737 if (selection_request_other (xa[XA_UTF8_STRING], i))
… …
2772 want_refresh = 1; 2791 want_refresh = 1;
2773 free (selection.text); 2792 free (selection.text);
2774 selection.text = NULL; 2793 selection.text = NULL;
2775 selection.len = 0; 2794 selection.len = 0;
2776 CLEAR_SELECTION (); 2795 CLEAR_SELECTION ();
2796
2797 if (display->selection_owner == this)
2798 display->selection_owner = 0;
2777} 2799}
2778 2800
2779/* ------------------------------------------------------------------------- */ 2801/* ------------------------------------------------------------------------- */
2780/* 2802/*
2781 * Copy a selection into the cut buffer 2803 * Copy a selection into the cut buffer
… …
2878 2900
2879 XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm); 2901 XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
2880 if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt) 2902 if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
2881 display->set_selection_owner (this); 2903 display->set_selection_owner (this);
2882 else 2904 else
2883 rxvt_print_error ("can't get primary selection"); 2905 rxvt_warn ("can't get primary selection, ignoring.\n");
2884 2906
2885#if 0 2907#if 0
2886 XTextProperty ct; 2908 XTextProperty ct;
2887 2909
2888 if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0) 2910 if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
… …
3392 /* TODO: Handle MULTIPLE */ 3414 /* TODO: Handle MULTIPLE */
3393 } 3415 }
3394 else if (rq.target == xa[XA_TIMESTAMP] && selection.text) 3416 else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3395 { 3417 {
3396 XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER, 3418 XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
3397 (8 * sizeof (Time)), PropModeReplace, 3419 (8 * sizeof (Time)), PropModeReplace,
3398 (unsigned char *)&selection_time, 1); 3420 (unsigned char *)&selection_time, 1);
3399 ev.property = rq.property; 3421 ev.property = rq.property;
3400 } 3422 }
3401 else if (rq.target == XA_STRING 3423 else if (rq.target == XA_STRING
3402 || rq.target == xa[XA_TEXT] 3424 || rq.target == xa[XA_TEXT]
3403 || rq.target == xa[XA_COMPOUND_TEXT] 3425 || rq.target == xa[XA_COMPOUND_TEXT]

Diff Legend

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