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

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.131 by root, Fri Aug 13 22:38:57 2004 UTC vs.
Revision 1.225 by root, Sun Jan 1 13:35:14 2006 UTC

… …
25 * - extensive modifications 25 * - extensive modifications
26 * Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org> 26 * Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org>
27 * Copyright (c) 2001 Marius Gedminas 27 * Copyright (c) 2001 Marius Gedminas
28 * - Ctrl/Mod4+Tab works like Meta+Tab (options) 28 * - Ctrl/Mod4+Tab works like Meta+Tab (options)
29 * Copyright (c) 2003 Rob McMullen <robm@flipturn.org> 29 * Copyright (c) 2003 Rob McMullen <robm@flipturn.org>
30 * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com> 30 * Copyright (c) 2003-2005 Marc Lehmann <pcg@goof.com>
31 * 31 *
32 * This program is free software; you can redistribute it and/or modify 32 * This program is free software; you can redistribute it and/or modify
33 * it under the terms of the GNU General Public License as published by 33 * it under the terms of the GNU General Public License as published by
34 * the Free Software Foundation; either version 2 of the License, or 34 * the Free Software Foundation; either version 2 of the License, or
35 * (at your option) any later version. 35 * (at your option) any later version.
… …
48#include "../config.h" /* NECESSARY */ 48#include "../config.h" /* NECESSARY */
49#include "rxvt.h" /* NECESSARY */ 49#include "rxvt.h" /* NECESSARY */
50#include "version.h" 50#include "version.h"
51#include "command.h" 51#include "command.h"
52 52
53#if HAVE_SCHED_YIELD
53#include <wchar.h> 54# include <sched.h>
55#endif
56
57#ifdef KEYSYM_RESOURCE
58# include "keyboard.h"
59#endif
60
61#include <csignal>
54 62
55/*----------------------------------------------------------------------*/ 63/*----------------------------------------------------------------------*/
56 64
57#define IS_CONTROL(ch) !((ch) & 0xffffff60UL) 65#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
58 66
59// exception thrown when the command parser runs out of input data 67// exception thrown when the command parser runs out of input data
60class out_of_input { } out_of_input; 68class out_of_input { } out_of_input;
61 69
62#ifndef NO_FRILLS 70#if ENABLE_FRILLS || ISO_14755
63 71
64#define ISO_14755_KEYCODE_VALID 0x80000000UL
65#define ISO_14755_ACTIVE 0x40000000UL 72#define ISO_14755_STARTED 0x80000000UL
66#define ISO_14755_ESCAPE_NEXT 0x20000000UL 73#define ISO_14755_51 0x40000000UL // basic (section 5.1)
74#define ISO_14755_52 0x20000000UL // keycap (section 5.2)
75#define ISO_14755_54 0x10000000UL // code feedback (section 5.4)
76#define ISO_14755_MASK 0x0fffffffUL
67 77
78#if ISO_14755
68static unsigned short iso14755_symtab[] = { 79static unsigned short iso14755_symtab[] = {
69 // keysym, unicode 80 // keysym, unicode
70 XK_Left, 0x2190, 81 XK_Left, 0x2190,
71 XK_KP_Left, 0x2190, 82 XK_KP_Left, 0x2190,
72 XK_Up, 0x2191, 83 XK_Up, 0x2191,
… …
110 XK_Escape, 0x238b, 121 XK_Escape, 0x238b,
111 XK_Undo, 0x238c, 122 XK_Undo, 0x238c,
112 XK_Print, 0x2399, 123 XK_Print, 0x2399,
113 124
114 XK_space, 0x2423, 125 XK_space, 0x2423,
126
127#ifdef XK_KP_Begin
128 XK_KP_Prior, 0x21de,
129 XK_KP_Next, 0x21df,
130 XK_KP_Begin, 0x2320,
131 XK_KP_Insert, 0x2380,
132 XK_KP_Delete, 0x2326,
115 XK_KP_Space, 0x2422, 133 XK_KP_Space, 0x2422,
134#endif
116 0, 135 0,
117}; 136};
118 137
119void 138void
139rxvt_term::iso14755_54 (int x, int y)
140{
141 x = Pixel2Col (x);
142 y = Pixel2Row (y);
143
144 if (!IN_RANGE_EXC (x, 0, ncol)
145 || !IN_RANGE_EXC (y, 0, nrow))
146 return;
147
148 for (;;)
149 {
150 const line_t &l = ROW(y - view_start);
151
152 text_t t = l.t[x];
153
154 if (t != NOCHAR || !x)
155 {
156 iso14755_51 (l.t[x], l.r[x], x, y);
157 iso14755buf = ISO_14755_54;
158 break;
159 }
160
161 x--;
162 }
163}
164
165void
166rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)
167{
168 rxvt_fontset *fs = FONTSET (r);
169 rxvt_font *f = (*fs)[fs->find_font (ch)];
170 wchar_t *chr, *alloc, ch2, *fname;
171 int len;
172
173 fname = rxvt_utf8towcs (f->name);
174
175# if ENABLE_COMBINING
176 if (IS_COMPOSE (ch))
177 {
178 len = rxvt_composite.expand (ch, 0);
179 alloc = chr = new wchar_t[len];
180 rxvt_composite.expand (ch, chr);
181 }
182 else
183# endif
184 {
185 ch2 = ch;
186
187 alloc = 0;
188 chr = &ch2;
189 len = 1;
190 }
191
192 char attr[80]; // plenty
193
194 sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
195 (int)r,
196 fgcolor_of (r), bgcolor_of (r),
197 r & RS_Bold ? " bold" : "",
198 r & RS_Italic ? " italic" : "",
199 r & RS_Blink ? " blink" : "",
200 r & RS_RVid ? " rvid" : "",
201 r & RS_Uline ? " uline" : "",
202 r & RS_Careful ? " careful" : "");
203
204 int width = wcswidth (fname, wcslen (fname));
205
206 max_it (width, 8+5); // for char + hey
207 max_it (width, strlen (attr));
208
209 if (y >= 0)
210 {
211 y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;
212 x = 0;
213 }
214
215 scr_overlay_new (x, y, width, len + 2);
216
217 r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
218
219 for (int y = 0; y < len; y++)
220 {
221 char buf[9];
222
223 ch = *chr++;
224
225 sprintf (buf, "%8x", ch);
226 scr_overlay_set (0, y, buf);
227 scr_overlay_set (9, y, '=');
228# if !UNICODE3
229 if (ch >= 0x10000)
230 ch = 0xfffd;
231# endif
232 scr_overlay_set (11, y, ch, r);
233 scr_overlay_set (12, y, NOCHAR, r);
234 }
235
236 scr_overlay_set (0, len , attr);
237 scr_overlay_set (0, len + 1, fname);
238
239 free (fname);
240
241# if ENABLE_COMBINING
242 if (alloc)
243 delete [] alloc;
244# endif
245}
246#endif
247
248void
120rxvt_term::commit_iso14755 () 249rxvt_term::commit_iso14755 ()
121{ 250{
122 wchar_t ch[2]; 251 wchar_t ch[2];
123 252
124 ch[0] = iso14755buf & 0x1fffffffUL; // actually, unicode needs a 0x1fffff mask 253 ch[0] = iso14755buf & ISO_14755_MASK;
125 ch[1] = 0; 254 ch[1] = 0;
126 255
127 if (iso14755buf & ISO_14755_KEYCODE_VALID) 256 if (iso14755buf & ISO_14755_51)
128 { 257 {
129 char mb[16]; 258 char mb[16];
130 int len; 259 int len;
131 260
132 // allow verbatim 0-bytes and control-bytes to be entered 261 // allow verbatim 0-bytes and control-bytes to be entered
… …
183 * use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an 312 * use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an
184 * escape sequence to toggle the Keypad. 313 * escape sequence to toggle the Keypad.
185 * 314 *
186 * Always permit `shift' to override the current setting 315 * Always permit `shift' to override the current setting
187 */ 316 */
188 shft = (ev.state & ShiftMask); 317 shft = ev.state & ShiftMask;
189 ctrl = (ev.state & ControlMask); 318 ctrl = ev.state & ControlMask;
190 meta = (ev.state & ModMetaMask); 319 meta = ev.state & ModMetaMask;
191 320
192 if (numlock_state || (ev.state & ModNumLockMask)) 321 if (numlock_state || (ev.state & ModNumLockMask))
193 { 322 {
194 numlock_state = (ev.state & ModNumLockMask); 323 numlock_state = (ev.state & ModNumLockMask);
195 PrivMode ((!numlock_state), PrivMode_aplKP); 324 PrivMode ((!numlock_state), PrivMode_aplKP);
… …
215 344
216 // the XOpenIM manpage lies about hardcoding the locale 345 // the XOpenIM manpage lies about hardcoding the locale
217 // at the point of XOpenIM, so temporarily switch locales 346 // at the point of XOpenIM, so temporarily switch locales
218 if (rs[Rs_imLocale]) 347 if (rs[Rs_imLocale])
219 SET_LOCALE (rs[Rs_imLocale]); 348 SET_LOCALE (rs[Rs_imLocale]);
349
220 // assume wchar_t == unicode or better 350 // assume wchar_t == unicode or better
221 len = XwcLookupString (Input_Context, &ev, wkbuf, 351 len = XwcLookupString (Input_Context, &ev, wkbuf,
222 KBUFSZ, &keysym, &status_return); 352 KBUFSZ, &keysym, &status_return);
353
223 if (rs[Rs_imLocale]) 354 if (rs[Rs_imLocale])
224 SET_LOCALE (locale); 355 SET_LOCALE (locale);
225 356
226 if (status_return == XLookupChars 357 if (status_return == XLookupChars
227 || status_return == XLookupBoth) 358 || status_return == XLookupBoth)
… …
254 valid_keysym = keysym != NoSymbol; 385 valid_keysym = keysym != NoSymbol;
255 } 386 }
256 387
257 if (valid_keysym) 388 if (valid_keysym)
258 { 389 {
390#ifdef KEYSYM_RESOURCE
391 if (keyboard->dispatch (this, keysym, ev.state))
392 return;
393#endif
394
259 if (TermWin.saveLines) 395 if (saveLines)
260 { 396 {
261#ifdef UNSHIFTED_SCROLLKEYS 397#ifdef UNSHIFTED_SCROLLKEYS
262 if (!ctrl && !meta) 398 if (!ctrl && !meta)
263#else 399#else
264 if (IS_SCROLL_MOD) 400 if (IS_SCROLL_MOD)
265#endif 401#endif
266 { 402 {
267 int lnsppg; 403 int lnsppg;
268 404
269#ifdef PAGING_CONTEXT_LINES 405#ifdef PAGING_CONTEXT_LINES
270 lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES; 406 lnsppg = nrow - PAGING_CONTEXT_LINES;
271#else 407#else
272 lnsppg = TermWin.nrow * 4 / 5; 408 lnsppg = nrow * 4 / 5;
273#endif 409#endif
274 if (keysym == XK_Prior) 410 if (keysym == XK_Prior)
275 { 411 {
276 scr_page (UP, lnsppg); 412 scr_page (UP, lnsppg);
277 return; 413 return;
… …
320 if (keysym >= XK_F1 && keysym <= XK_F10) 456 if (keysym >= XK_F1 && keysym <= XK_F10)
321 { 457 {
322 keysym += (XK_F11 - XK_F1); 458 keysym += (XK_F11 - XK_F1);
323 shft = 0; /* turn off Shift */ 459 shft = 0; /* turn off Shift */
324 } 460 }
325 else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys)) 461 else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
326 { 462 {
327 switch (keysym) 463 switch (keysym)
328 { 464 {
329 /* normal XTerm key bindings */ 465 /* normal XTerm key bindings */
330 case XK_Insert: /* Shift+Insert = paste mouse selection */ 466 case XK_Insert: /* Shift+Insert = paste mouse selection */
331 selection_request (ev.time, 0, 0); 467 selection_request (ev.time, 0, 0);
332 return; 468 return;
333#if TODO // TODO 469#if TODO
334 /* rxvt extras */ 470 /* rxvt extras */
335 case XK_KP_Add: /* Shift+KP_Add = bigger font */ 471 case XK_KP_Add: /* Shift+KP_Add = bigger font */
336 change_font (FONT_UP); 472 change_font (FONT_UP);
337 return; 473 return;
338 case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */ 474 case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
… …
341#endif 477#endif
342 } 478 }
343 } 479 }
344 } 480 }
345 481
346#ifndef NO_FRILLS 482#if ENABLE_FRILLS || ISO_14755
347 // ISO 14755 support 483 // ISO 14755 support
348 if (shft && ctrl) 484 if (shft && ctrl)
349 { 485 {
350 int hv; 486 int hv;
351 487
488 if (iso14755buf & ISO_14755_51
352 if (keysym == XK_space || keysym == XK_KP_Space 489 && (keysym == XK_space || keysym == XK_KP_Space
353 || keysym == XK_Return || keysym == XK_KP_Enter) 490 || keysym == XK_Return || keysym == XK_KP_Enter))
354 { 491 {
355 commit_iso14755 (); 492 commit_iso14755 ();
493 iso14755buf = ISO_14755_51;
494# if ISO_14755
495 iso14755_51 (0);
496# endif
356 return; 497 return;
357 } 498 }
358 else if ((hv = hex_keyval (ev)) >= 0) 499 else if ((hv = hex_keyval (ev)) >= 0)
359 { 500 {
360 iso14755buf = (iso14755buf << 4) | hv | ISO_14755_KEYCODE_VALID; 501 iso14755buf = ((iso14755buf << 4) & ISO_14755_MASK)
502 | hv | ISO_14755_51;
503# if ISO_14755
504 iso14755_51 (iso14755buf & ISO_14755_MASK);
505# endif
361 return; 506 return;
362 } 507 }
363 else 508 else
509 {
510# if ENABLE_OVERLAY
511 scr_overlay_off ();
512# endif
364 iso14755buf = 0; 513 iso14755buf = 0;
514 }
365 } 515 }
366 else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R)) 516 else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
367 || (shft && (keysym == XK_Control_L || keysym == XK_Control_R))) 517 || (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))
518 if (!(iso14755buf & ISO_14755_STARTED))
519 {
368 iso14755buf |= ISO_14755_ACTIVE; 520 iso14755buf |= ISO_14755_STARTED;
521# if ENABLE_OVERLAY
522 scr_overlay_new (0, -1, sizeof ("ISO 14755 mode") - 1, 1);
523 scr_overlay_set (0, 0, "ISO 14755 mode");
524# endif
525 }
369#endif 526#endif
370 527
371#ifdef PRINTPIPE 528#ifdef PRINTPIPE
372 if (keysym == XK_Print) 529 if (keysym == XK_Print)
373 { 530 {
… …
376 } 533 }
377#endif 534#endif
378 535
379 if (keysym >= 0xFF00 && keysym <= 0xFFFF) 536 if (keysym >= 0xFF00 && keysym <= 0xFFFF)
380 { 537 {
381#ifdef KEYSYM_RESOURCE
382 if (! (shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)
383 {
384 unsigned int l;
385 const unsigned char *kbuf0;
386
387 kbuf0 = (Keysym_map[keysym & 0xFF]);
388 l = (unsigned int)*kbuf0++;
389
390 /* escape prefix */
391 if (meta
392# ifdef META8_OPTION
393 && meta_char == C0_ESC
394# endif
395 )
396 {
397 const unsigned char ch = C0_ESC;
398 tt_write (&ch, 1);
399 }
400
401 tt_write (kbuf0, l);
402 return;
403 }
404 else
405#endif
406 { 538 {
407 newlen = 1; 539 newlen = 1;
408 switch (keysym) 540 switch (keysym)
409 { 541 {
410#ifndef NO_BACKSPACE_KEY 542#ifndef NO_BACKSPACE_KEY
411 case XK_BackSpace: 543 case XK_BackSpace:
412 if (PrivateModes & PrivMode_HaveBackSpace) 544 if (priv_modes & PrivMode_HaveBackSpace)
413 { 545 {
414 kbuf[0] = (!! (PrivateModes & PrivMode_BackSpace) 546 kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
415 ^ !!ctrl) ? '\b' : '\177'; 547 ^ !!ctrl) ? '\b' : '\177';
416 kbuf[1] = '\0'; 548 kbuf[1] = '\0';
417 } 549 }
418 else 550 else
419 STRCPY (kbuf, key_backspace); 551 strcpy (kbuf, key_backspace);
420 break; 552 break;
421#endif 553#endif
422#ifndef NO_DELETE_KEY 554#ifndef NO_DELETE_KEY
555# ifdef XK_KP_Prior
556 case XK_KP_Delete:
557 /* allow shift to override */
558 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
559 {
560 strcpy (kbuf, "\033On");
561 break;
562 }
563 /* FALLTHROUGH */
564# endif
423 case XK_Delete: 565 case XK_Delete:
424 STRCPY (kbuf, key_delete); 566 strcpy (kbuf, key_delete);
425 break; 567 break;
426#endif 568#endif
427 case XK_Tab: 569 case XK_Tab:
428 if (shft) 570 if (shft)
429 STRCPY (kbuf, "\033[Z"); 571 strcpy (kbuf, "\033[Z");
430 else 572 else
431 { 573 {
432#ifdef CTRL_TAB_MAKES_META 574#ifdef CTRL_TAB_MAKES_META
433 if (ctrl) 575 if (ctrl)
434 meta = 1; 576 meta = 1;
… …
444#ifdef XK_KP_Left 586#ifdef XK_KP_Left
445 case XK_KP_Up: /* \033Ox or standard */ 587 case XK_KP_Up: /* \033Ox or standard */
446 case XK_KP_Down: /* \033Or or standard */ 588 case XK_KP_Down: /* \033Or or standard */
447 case XK_KP_Right: /* \033Ov or standard */ 589 case XK_KP_Right: /* \033Ov or standard */
448 case XK_KP_Left: /* \033Ot or standard */ 590 case XK_KP_Left: /* \033Ot or standard */
449 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 591 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
450 { 592 {
451 STRCPY (kbuf, "\033OZ"); 593 strcpy (kbuf, "\033OZ");
452 kbuf[2] = "txvr"[keysym - XK_KP_Left]; 594 kbuf[2] = "txvr"[keysym - XK_KP_Left];
453 break; 595 break;
454 } 596 }
455 else 597 else
456 /* translate to std. cursor key */ 598 /* translate to std. cursor key */
… …
459#endif 601#endif
460 case XK_Up: /* "\033[A" */ 602 case XK_Up: /* "\033[A" */
461 case XK_Down: /* "\033[B" */ 603 case XK_Down: /* "\033[B" */
462 case XK_Right: /* "\033[C" */ 604 case XK_Right: /* "\033[C" */
463 case XK_Left: /* "\033[D" */ 605 case XK_Left: /* "\033[D" */
464 STRCPY (kbuf, "\033[Z"); 606 strcpy (kbuf, "\033[Z");
465 kbuf[2] = "DACB"[keysym - XK_Left]; 607 kbuf[2] = "DACB"[keysym - XK_Left];
466 /* do Shift first */ 608 /* do Shift first */
467 if (shft) 609 if (shft)
468 kbuf[2] = "dacb"[keysym - XK_Left]; 610 kbuf[2] = "dacb"[keysym - XK_Left];
469 else if (ctrl) 611 else if (ctrl)
470 { 612 {
471 kbuf[1] = 'O'; 613 kbuf[1] = 'O';
472 kbuf[2] = "dacb"[keysym - XK_Left]; 614 kbuf[2] = "dacb"[keysym - XK_Left];
473 } 615 }
474 else if (PrivateModes & PrivMode_aplCUR) 616 else if (priv_modes & PrivMode_aplCUR)
475 kbuf[1] = 'O'; 617 kbuf[1] = 'O';
476 break; 618 break;
477 619
478#ifndef UNSHIFTED_SCROLLKEYS 620#ifndef UNSHIFTED_SCROLLKEYS
479# ifdef XK_KP_Prior 621# ifdef XK_KP_Prior
480 case XK_KP_Prior: 622 case XK_KP_Prior:
481 /* allow shift to override */ 623 /* allow shift to override */
482 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 624 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
483 { 625 {
484 STRCPY (kbuf, "\033Oy"); 626 strcpy (kbuf, "\033Oy");
485 break; 627 break;
486 } 628 }
487 /* FALLTHROUGH */ 629 /* FALLTHROUGH */
488# endif 630# endif
489 case XK_Prior: 631 case XK_Prior:
490 STRCPY (kbuf, "\033[5~"); 632 strcpy (kbuf, "\033[5~");
491 break; 633 break;
492# ifdef XK_KP_Next 634# ifdef XK_KP_Next
493 case XK_KP_Next: 635 case XK_KP_Next:
494 /* allow shift to override */ 636 /* allow shift to override */
495 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 637 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
496 { 638 {
497 STRCPY (kbuf, "\033Os"); 639 strcpy (kbuf, "\033Os");
498 break; 640 break;
499 } 641 }
500 /* FALLTHROUGH */ 642 /* FALLTHROUGH */
501# endif 643# endif
502 case XK_Next: 644 case XK_Next:
503 STRCPY (kbuf, "\033[6~"); 645 strcpy (kbuf, "\033[6~");
504 break; 646 break;
505#endif 647#endif
506 case XK_KP_Enter: 648 case XK_KP_Enter:
507 /* allow shift to override */ 649 /* allow shift to override */
508 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 650 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
509 { 651 {
510 STRCPY (kbuf, "\033OM"); 652 strcpy (kbuf, "\033OM");
653 break;
654 }
655
656 /* FALLTHROUGH */
657
658 case XK_Return:
659 if (priv_modes & PrivMode_LFNL)
660 {
661 kbuf[0] = '\015';
662 kbuf[1] = '\012';
663 kbuf[2] = '\0';
511 } 664 }
512 else 665 else
513 { 666 {
514 kbuf[0] = '\r'; 667 kbuf[0] = '\015';
515 kbuf[1] = '\0'; 668 kbuf[1] = '\0';
516 } 669 }
517 break; 670 break;
518 671
519#ifdef XK_KP_Begin 672#ifdef XK_KP_Begin
520 case XK_KP_Begin: 673 case XK_KP_Begin:
521 STRCPY (kbuf, "\033Ou"); 674 strcpy (kbuf, "\033Ou");
522 break; 675 break;
523 676
524 case XK_KP_Insert:
525 STRCPY (kbuf, "\033Op");
526 break;
527
528 case XK_KP_Delete:
529 STRCPY (kbuf, "\033On");
530 break;
531#endif 677#endif
532 case XK_KP_F1: /* "\033OP" */ 678 case XK_KP_F1: /* "\033OP" */
533 case XK_KP_F2: /* "\033OQ" */ 679 case XK_KP_F2: /* "\033OQ" */
534 case XK_KP_F3: /* "\033OR" */ 680 case XK_KP_F3: /* "\033OR" */
535 case XK_KP_F4: /* "\033OS" */ 681 case XK_KP_F4: /* "\033OS" */
536 STRCPY (kbuf, "\033OP"); 682 strcpy (kbuf, "\033OP");
537 kbuf[2] += (keysym - XK_KP_F1); 683 kbuf[2] += (keysym - XK_KP_F1);
538 break; 684 break;
539 685
540 case XK_KP_Multiply: /* "\033Oj" : "*" */ 686 case XK_KP_Multiply: /* "\033Oj" : "*" */
541 case XK_KP_Add: /* "\033Ok" : "+" */ 687 case XK_KP_Add: /* "\033Ok" : "+" */
… …
552 case XK_KP_6: /* "\033Ov" : "6" */ 698 case XK_KP_6: /* "\033Ov" : "6" */
553 case XK_KP_7: /* "\033Ow" : "7" */ 699 case XK_KP_7: /* "\033Ow" : "7" */
554 case XK_KP_8: /* "\033Ox" : "8" */ 700 case XK_KP_8: /* "\033Ox" : "8" */
555 case XK_KP_9: /* "\033Oy" : "9" */ 701 case XK_KP_9: /* "\033Oy" : "9" */
556 /* allow shift to override */ 702 /* allow shift to override */
557 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 703 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
558 { 704 {
559 STRCPY (kbuf, "\033Oj"); 705 strcpy (kbuf, "\033Oj");
560 kbuf[2] += (keysym - XK_KP_Multiply); 706 kbuf[2] += (keysym - XK_KP_Multiply);
561 } 707 }
562 else 708 else
563 { 709 {
564 kbuf[0] = ('*' + (keysym - XK_KP_Multiply)); 710 kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
565 kbuf[1] = '\0'; 711 kbuf[1] = '\0';
566 } 712 }
567 break; 713 break;
568 714
569 case XK_Find: 715 case XK_Find:
570 STRCPY (kbuf, "\033[1~"); 716 strcpy (kbuf, "\033[1~");
571 break; 717 break;
718
719#ifdef XK_KP_End
720 case XK_KP_Insert:
721 /* allow shift to override */
722 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
723 {
724 strcpy (kbuf, "\033Op");
725 break;
726 }
727 /* FALLTHROUGH */
728#endif
572 case XK_Insert: 729 case XK_Insert:
573 STRCPY (kbuf, "\033[2~"); 730 strcpy (kbuf, "\033[2~");
574 break; 731 break;
575#ifdef DXK_Remove /* support for DEC remove like key */ 732#ifdef DXK_Remove /* support for DEC remove like key */
576 case DXK_Remove: 733 case DXK_Remove:
577 /* FALLTHROUGH */ 734 /* FALLTHROUGH */
578#endif 735#endif
579 case XK_Execute: 736 case XK_Execute:
580 STRCPY (kbuf, "\033[3~"); 737 strcpy (kbuf, "\033[3~");
581 break; 738 break;
582 case XK_Select: 739 case XK_Select:
583 STRCPY (kbuf, "\033[4~"); 740 strcpy (kbuf, "\033[4~");
584 break; 741 break;
585#ifdef XK_KP_End 742#ifdef XK_KP_End
586 case XK_KP_End: 743 case XK_KP_End:
587 /* allow shift to override */ 744 /* allow shift to override */
588 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 745 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
589 { 746 {
590 STRCPY (kbuf, "\033Oq"); 747 strcpy (kbuf, "\033Oq");
591 break; 748 break;
592 } 749 }
593 /* FALLTHROUGH */ 750 /* FALLTHROUGH */
594#endif 751#endif
595 case XK_End: 752 case XK_End:
596 STRCPY (kbuf, KS_END); 753 strcpy (kbuf, KS_END);
597 break; 754 break;
598#ifdef XK_KP_Home 755#ifdef XK_KP_Home
599 case XK_KP_Home: 756 case XK_KP_Home:
600 /* allow shift to override */ 757 /* allow shift to override */
601 if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) 758 if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
602 { 759 {
603 STRCPY (kbuf, "\033Ow"); 760 strcpy (kbuf, "\033Ow");
604 break; 761 break;
605 } 762 }
606 /* FALLTHROUGH */ 763 /* FALLTHROUGH */
607#endif 764#endif
608 case XK_Home: 765 case XK_Home:
609 STRCPY (kbuf, KS_HOME); 766 strcpy (kbuf, KS_HOME);
610 break; 767 break;
611 768
612#define FKEY(n, fkey) \ 769#define FKEY(n, fkey) \
613 sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey))) 770 sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))
614 771
… …
666#undef FKEY 823#undef FKEY
667 default: 824 default:
668 newlen = 0; 825 newlen = 0;
669 break; 826 break;
670 } 827 }
828
671 if (newlen) 829 if (newlen)
672 len = STRLEN (kbuf); 830 len = strlen (kbuf);
673 } 831 }
674 832
675 /* 833 /*
676 * Pass meta for all function keys, if 'meta' option set 834 * Pass meta for all function keys, if 'meta' option set
677 */ 835 */
… …
684 else if (ctrl && keysym == XK_minus) 842 else if (ctrl && keysym == XK_minus)
685 { 843 {
686 len = 1; 844 len = 1;
687 kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */ 845 kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
688 } 846 }
847 else if (keysym == XK_ISO_Left_Tab)
848 {
849 strcpy (kbuf, "\033[Z");
850 len = 3;
851 }
689 else 852 else
690 { 853 {
691#ifdef META8_OPTION 854#ifdef META8_OPTION
692 /* set 8-bit on */ 855 /* set 8-bit on */
693 if (meta && (meta_char == 0x80)) 856 if (meta && (meta_char == 0x80))
… …
705 } 868 }
706 869
707 if (len <= 0) 870 if (len <= 0)
708 return; /* not mapped */ 871 return; /* not mapped */
709 872
710 if (Options & Opt_scrollTtyKeypress) 873 if (OPTION (Opt_scrollTtyKeypress))
711 if (TermWin.view_start) 874 if (view_start)
712 { 875 {
713 TermWin.view_start = 0; 876 view_start = 0;
714 want_refresh = 1; 877 want_refresh = 1;
715 } 878 }
716 879
717 /* 880 /*
718 * these modifications only affect the static keybuffer 881 * these modifications only affect the static keybuffer
… …
751#endif /* DEBUG_CMD */ 914#endif /* DEBUG_CMD */
752 tt_write (kbuf, (unsigned int)len); 915 tt_write (kbuf, (unsigned int)len);
753} 916}
754/*}}} */ 917/*}}} */
755 918
756#if (MENUBAR_MAX) 919#if MENUBAR_MAX || defined (KEYSYM_RESOURCE)
757/*{{{ rxvt_cmd_write (), rxvt_cmd_getc () */ 920/*{{{ rxvt_cmd_write (), rxvt_cmd_getc () */
758/* attempt to `write' count to the input buffer */ 921/* attempt to `write' count to the input buffer */
759unsigned int 922unsigned int
760rxvt_term::cmd_write (const unsigned char *str, unsigned int count) 923rxvt_term::cmd_write (const unsigned char *str, unsigned int count)
761{ 924{
… …
764 n = cmdbuf_ptr - cmdbuf_base; 927 n = cmdbuf_ptr - cmdbuf_base;
765 s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp; 928 s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
766 929
767 if (n > 0 && s < count) 930 if (n > 0 && s < count)
768 { 931 {
769 MEMMOVE (cmdbuf_base, cmdbuf_ptr, 932 memmove (cmdbuf_base, cmdbuf_ptr,
770 (unsigned int) (cmdbuf_endp - cmdbuf_ptr)); 933 (unsigned int) (cmdbuf_endp - cmdbuf_ptr));
771 cmdbuf_ptr = cmdbuf_base; 934 cmdbuf_ptr = cmdbuf_base;
772 cmdbuf_endp -= n; 935 cmdbuf_endp -= n;
773 s += n; 936 s += n;
774 } 937 }
… …
784 947
785 cmd_parse (); 948 cmd_parse ();
786 949
787 return 0; 950 return 0;
788} 951}
789#endif /* MENUBAR_MAX */ 952#endif
790 953
791void 954void
792rxvt_term::flush () 955rxvt_term::flush ()
793{ 956{
957 flush_ev.stop ();
958
794#ifdef TRANSPARENT 959#ifdef TRANSPARENT
795 if (want_full_refresh) 960 if (want_full_refresh)
796 { 961 {
797 want_full_refresh = 0; 962 want_full_refresh = 0;
798 scr_clear (); 963 scr_clear ();
… …
808 IMSendSpot (); 973 IMSendSpot ();
809#endif 974#endif
810 } 975 }
811 976
812 display->flush (); 977 display->flush ();
813
814 flush_ev.stop ();
815} 978}
816 979
817void 980void
818rxvt_term::check_cb (check_watcher &w) 981rxvt_term::check_cb (check_watcher &w)
819{ 982{
… …
895{ 1058{
896 if (mouse_slip_wheel_speed == 0 1059 if (mouse_slip_wheel_speed == 0
897 || mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed) 1060 || mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
898 : scr_page (UP, mouse_slip_wheel_speed)) 1061 : scr_page (UP, mouse_slip_wheel_speed))
899 { 1062 {
1063 if (view_start == nsaved ||
1064 view_start == 0)
1065 mouse_slip_wheel_speed = 0;
1066
900 refresh_type |= SMOOTH_REFRESH; 1067 refresh_type |= SMOOTH_REFRESH;
901 want_refresh = 1; 1068 want_refresh = 1;
902 w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY); 1069 w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
903 } 1070 }
904} 1071}
… …
917 1084
918 memmove (cmdbuf_base, cmdbuf_ptr, n); 1085 memmove (cmdbuf_base, cmdbuf_ptr, n);
919 cmdbuf_ptr = cmdbuf_base; 1086 cmdbuf_ptr = cmdbuf_base;
920 cmdbuf_endp = cmdbuf_ptr + n; 1087 cmdbuf_endp = cmdbuf_ptr + n;
921 1088
922 n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n); 1089 ssize_t r = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
923 1090
924 if (n > 0) 1091 if (r > 0)
925 { 1092 {
926 cmdbuf_endp += n; 1093 cmdbuf_endp += r;
927 return true; 1094 return true;
928 } 1095 }
929 else if (n < 0 && errno != EAGAIN) 1096 else if (r < 0 && (errno == EAGAIN || errno == EINTR))
1097 {
1098#if HAVE_SCHED_YIELD
1099 sched_yield ();
1100#endif
1101 }
1102 else
1103 {
1104 pty_ev.stop ();
1105
1106 if (!OPTION (Opt_hold))
930 destroy (); 1107 destroy ();
1108 }
931 1109
932 return false; 1110 return false;
933} 1111}
934 1112
935void 1113void
936rxvt_term::pty_cb (io_watcher &w, short revents) 1114rxvt_term::pty_cb (io_watcher &w, short revents)
937{ 1115{
938 SET_R (this); 1116 SET_R (this);
939 SET_LOCALE (locale); 1117 SET_LOCALE (locale);
940 1118
941 if (revents & EVENT_WRITE)
942 tt_write (0, 0);
943 else if (revents & EVENT_READ) 1119 if (revents & EVENT_READ)
944 // loop, but don't allow a single term to monopolize us 1120 // loop, but don't allow a single term to monopolize us
945 while (pty_fill ()) 1121 while (pty_fill ())
946 if (cmd_parse ()) 1122 if (cmd_parse ())
947 break; 1123 break;
1124
1125 if (revents & EVENT_WRITE)
1126 pty_write ();
948} 1127}
949 1128
950void 1129void
951rxvt_term::pointer_unblank () 1130rxvt_term::pointer_unblank ()
952{ 1131{
953 XDefineCursor (display->display, TermWin.vt, TermWin_cursor); 1132 XDefineCursor (display->display, vt, TermWin_cursor);
954 recolour_cursor (); 1133 recolour_cursor ();
955 1134
956#ifdef POINTER_BLANK 1135#ifdef POINTER_BLANK
957 hidden_pointer = 0; 1136 hidden_pointer = 0;
958 1137
959 if (Options & Opt_pointerBlank) 1138 if (OPTION (Opt_pointerBlank))
960 pointer_ev.start (NOW + pointerBlankDelay); 1139 pointer_ev.start (NOW + pointerBlankDelay);
961#endif 1140#endif
962} 1141}
963 1142
964#ifdef POINTER_BLANK 1143#ifdef POINTER_BLANK
965void 1144void
966rxvt_term::pointer_blank () 1145rxvt_term::pointer_blank ()
967{ 1146{
968 if (! (Options & Opt_pointerBlank)) 1147 if (! OPTION (Opt_pointerBlank))
969 return; 1148 return;
970 1149
971 XDefineCursor (display->display, TermWin.vt, blank_cursor); 1150 XDefineCursor (display->display, vt, display->blank_cursor);
972 XFlush (display->display); 1151 XFlush (display->display);
973 1152
974 hidden_pointer = 1; 1153 hidden_pointer = 1;
975} 1154}
976 1155
… …
993 x = ev.x; 1172 x = ev.x;
994 y = ev.y; 1173 y = ev.y;
995 pixel_position (&x, &y); 1174 pixel_position (&x, &y);
996 1175
997 if (MEvent.button == AnyButton) 1176 if (MEvent.button == AnyButton)
998 {
999 button_number = 3; 1177 button_number = 3;
1000 }
1001 else 1178 else
1002 { 1179 {
1003 button_number = MEvent.button - Button1; 1180 button_number = MEvent.button - Button1;
1004 /* add 0x3D for wheel events, like xterm does */ 1181 /* add 0x3D for wheel events, like xterm does */
1005 if (button_number >= 3) 1182 if (button_number >= 3)
1006 button_number += (64 - 3); 1183 button_number += (64 - 3);
1007 } 1184 }
1008 1185
1009 if (PrivateModes & PrivMode_MouseX10) 1186 if (priv_modes & PrivMode_MouseX10)
1010 { 1187 {
1011 /* 1188 /*
1012 * do not report ButtonRelease 1189 * do not report ButtonRelease
1013 * no state info allowed 1190 * no state info allowed
1014 */ 1191 */
… …
1029 + ((MEvent.state & ModMetaMask) ? 8 : 0) 1206 + ((MEvent.state & ModMetaMask) ? 8 : 0)
1030 + ((MEvent.state & ControlMask) ? 16 : 0); 1207 + ((MEvent.state & ControlMask) ? 16 : 0);
1031#ifdef MOUSE_REPORT_DOUBLECLICK 1208#ifdef MOUSE_REPORT_DOUBLECLICK
1032 key_state += ((MEvent.clicks > 1) ? 32 : 0); 1209 key_state += ((MEvent.clicks > 1) ? 32 : 0);
1033#endif 1210#endif
1034
1035 } 1211 }
1036 1212
1037#ifdef DEBUG_MOUSEREPORT 1213#if DEBUG_MOUSEREPORT
1038 fprintf (stderr, "Mouse ["); 1214 fprintf (stderr, "Mouse [");
1039 if (key_state & 16) 1215 if (key_state & 16)
1040 fputc ('C', stderr); 1216 fputc ('C', stderr);
1041 if (key_state & 4) 1217 if (key_state & 4)
1042 fputc ('S', stderr); 1218 fputc ('S', stderr);
… …
1046 fputc ('2', stderr); 1222 fputc ('2', stderr);
1047 fprintf (stderr, "]: <%d>, %d/%d\n", 1223 fprintf (stderr, "]: <%d>, %d/%d\n",
1048 button_number, 1224 button_number,
1049 x + 1, 1225 x + 1,
1050 y + 1); 1226 y + 1);
1051#else 1227#endif
1228
1052 tt_printf ("\033[M%c%c%c", 1229 tt_printf ("\033[M%c%c%c",
1053 (32 + button_number + key_state), 1230 (32 + button_number + key_state),
1054 (32 + x + 1), 1231 (32 + x + 1),
1055 (32 + y + 1)); 1232 (32 + y + 1));
1056#endif
1057} 1233}
1058 1234
1059#ifdef USING_W11LIB 1235#ifdef USING_W11LIB
1060void 1236void
1061rxvt_W11_process_x_event (XEvent *ev) 1237rxvt_W11_process_x_event (XEvent *ev)
… …
1068 1244
1069/*{{{ process an X event */ 1245/*{{{ process an X event */
1070void 1246void
1071rxvt_term::x_cb (XEvent &ev) 1247rxvt_term::x_cb (XEvent &ev)
1072{ 1248{
1249 dDisp;
1250
1073 SET_R (this); 1251 SET_R (this);
1074 SET_LOCALE (locale); 1252 SET_LOCALE (locale);
1075 1253
1076#if defined(CURSOR_BLINK) 1254#if defined(CURSOR_BLINK)
1077 if ((Options & Opt_cursorBlink) && ev.type == KeyPress) 1255 if (OPTION (Opt_cursorBlink) && ev.type == KeyPress)
1078 { 1256 {
1079 if (hidden_cursor) 1257 if (hidden_cursor)
1080 { 1258 {
1081 hidden_cursor = 0; 1259 hidden_cursor = 0;
1082 want_refresh = 1; 1260 want_refresh = 1;
… …
1085 cursor_blink_ev.start (NOW + BLINK_INTERVAL); 1263 cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1086 } 1264 }
1087#endif 1265#endif
1088 1266
1089#if defined(POINTER_BLANK) 1267#if defined(POINTER_BLANK)
1090 if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0) 1268 if (OPTION (Opt_pointerBlank) && pointerBlankDelay > 0)
1091 { 1269 {
1092 if (ev.type == MotionNotify 1270 if (ev.type == MotionNotify
1093 || ev.type == ButtonPress 1271 || ev.type == ButtonPress
1094 || ev.type == ButtonRelease) 1272 || ev.type == ButtonRelease)
1095 if (hidden_pointer) 1273 if (hidden_pointer)
… …
1098 if (ev.type == KeyPress && hidden_pointer == 0) 1276 if (ev.type == KeyPress && hidden_pointer == 0)
1099 pointer_blank (); 1277 pointer_blank ();
1100 } 1278 }
1101#endif 1279#endif
1102 1280
1103#ifdef USE_XIM
1104 if (XFilterEvent (&ev, None))
1105 return;
1106#endif
1107
1108 Window unused_root, unused_child; 1281 Window unused_root, unused_child;
1109 int unused_root_x, unused_root_y; 1282 int unused_root_x, unused_root_y;
1110 unsigned int unused_mask; 1283 unsigned int unused_mask;
1111
1112#ifdef DEBUG_X
1113 const char *const eventnames[] =
1114 { /* mason - this matches my system */
1115 "",
1116 "",
1117 "KeyPress",
1118 "KeyRelease",
1119 "ButtonPress",
1120 "ButtonRelease",
1121 "MotionNotify",
1122 "EnterNotify",
1123 "LeaveNotify",
1124 "FocusIn",
1125 "FocusOut",
1126 "KeymapNotify",
1127 "Expose",
1128 "GraphicsExpose",
1129 "NoExpose",
1130 "VisibilityNotify",
1131 "CreateNotify",
1132 "DestroyNotify",
1133 "UnmapNotify",
1134 "MapNotify",
1135 "MapRequest",
1136 "ReparentNotify",
1137 "ConfigureNotify",
1138 "ConfigureRequest",
1139 "GravityNotify",
1140 "ResizeRequest",
1141 "CirculateNotify",
1142 "CirculateRequest",
1143 "PropertyNotify",
1144 "SelectionClear",
1145 "SelectionRequest",
1146 "SelectionNotify",
1147 "ColormapNotify",
1148 "ClientMessage",
1149 "MappingNotify"
1150 };
1151#endif
1152
1153#ifdef DEBUG_X
1154 struct timeval tp;
1155 struct tm *ltt;
1156 (void)gettimeofday (&tp, NULL);
1157 ltt = localtime (& (tp.tv_sec));
1158 D_X ((stderr, "Event: %-16s %-7s %08lx (%4d-%02d-%02d %02d:%02d:%02d.%.6ld) %s %lu", eventnames[ev.type], (ev.xany.window == TermWin.parent[0] ? "parent" : (ev.xany.window == TermWin.vt ? "vt" : (ev.xany.window == scrollBar.win ? "scroll" : (ev.xany.window == menuBar.win ? "menubar" : "UNKNOWN")))), (ev.xany.window == TermWin.parent[0] ? TermWin.parent[0] : (ev.xany.window == TermWin.vt ? TermWin.vt : (ev.xany.window == scrollBar.win ? scrollBar.win : (ev.xany.window == menuBar.win ? menuBar.win : 0)))), ltt->tm_year + 1900, ltt->tm_mon + 1, ltt->tm_mday, ltt->tm_hour, ltt->tm_min, ltt->tm_sec, tp.tv_usec, ev.xany.send_event ? "S" : " ", ev.xany.serial));
1159#endif
1160 1284
1161 switch (ev.type) 1285 switch (ev.type)
1162 { 1286 {
1163 case KeyPress: 1287 case KeyPress:
1288#if ISO_14755
1164 if (!(iso14755buf & ISO_14755_ESCAPE_NEXT)) 1289 if (!(iso14755buf & ISO_14755_52))
1290#endif
1165 lookup_key (ev.xkey); 1291 lookup_key (ev.xkey);
1166 1292
1167 break; 1293 break;
1168 1294
1169 case KeyRelease: 1295 case KeyRelease:
1170 { 1296 {
1171#if (defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)) || !defined (NO_FRILLS) 1297#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755
1172 KeySym ks; 1298 KeySym ks;
1173 1299
1174 ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/ 1300 ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
1175#endif 1301#endif
1176 1302
1177#ifndef NO_FRILLS 1303#if ENABLE_FRILLS || ISO_14755
1178 // ISO 14755 support 1304 // ISO 14755 support
1179 if (iso14755buf) 1305 if (iso14755buf)
1180 if (iso14755buf & ISO_14755_ESCAPE_NEXT) 1306 if (iso14755buf & ISO_14755_52)
1181 { 1307 {
1308# if ENABLE_OVERLAY
1309 scr_overlay_off ();
1310# endif
1311# if ISO_14755
1182 // iso14755 part 5.2 handling: release time 1312 // iso14755 part 5.2 handling: release time
1183 // first: controls 1313 // first: controls
1184 if ((ev.xkey.state & ControlMask) 1314 if ((ev.xkey.state & ControlMask)
1185 && ((ks >= 0x40 && ks <= 0x5f) 1315 && ((ks >= 0x40 && ks <= 0x5f)
1186 || (ks >= 0x61 && ks <= 0x7f))) 1316 || (ks >= 0x61 && ks <= 0x7f)))
1187 { 1317 {
1188 iso14755buf = ISO_14755_KEYCODE_VALID | 0x2400 | (ks & 0x1f); 1318 iso14755buf = ISO_14755_51 | 0x2400 | (ks & 0x1f);
1189 commit_iso14755 (); 1319 commit_iso14755 ();
1190 return; // case-break; 1320 return; // case-break;
1191 } 1321 }
1192 1322
1193 for (unsigned short *i = iso14755_symtab; i[0]; i+= 2) 1323 for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
1194 if (i[0] == ks) 1324 if (i[0] == ks)
1195 { 1325 {
1196 iso14755buf = ISO_14755_KEYCODE_VALID | i[1]; 1326 iso14755buf = ISO_14755_51 | i[1];
1197 commit_iso14755 (); 1327 commit_iso14755 ();
1198 return; // case-break; 1328 return; // case-break;
1199 } 1329 }
1200 1330
1331 scr_bell ();
1332# endif
1201 iso14755buf = 0; 1333 iso14755buf = 0;
1202 scr_bell ();
1203 break; 1334 break;
1204 } 1335 }
1205 else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask)) 1336 else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
1206 { 1337 {
1338# if ENABLE_OVERLAY
1339 scr_overlay_off ();
1340# endif
1207 if (iso14755buf & ISO_14755_KEYCODE_VALID) 1341 if (iso14755buf & ISO_14755_51)
1208 commit_iso14755 (); 1342 commit_iso14755 ();
1343#if ISO_14755
1209 else if (iso14755buf & ISO_14755_ACTIVE) 1344 else if (iso14755buf & ISO_14755_STARTED)
1345 {
1210 iso14755buf = ISO_14755_ESCAPE_NEXT; // iso14755 part 5.2: remember empty begin/end pair 1346 iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
1347
1348 scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
1349 scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
1350 }
1351# endif
1352 else
1353 iso14755buf = 0;
1211 } 1354 }
1212#endif 1355#endif
1213 1356
1214#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING) 1357#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1215 if (!(ev.xkey.state & ControlMask)) 1358 if (!(ev.xkey.state & ControlMask))
… …
1228 button_release (ev.xbutton); 1371 button_release (ev.xbutton);
1229 break; 1372 break;
1230 1373
1231 case ClientMessage: 1374 case ClientMessage:
1232 if (ev.xclient.format == 32 1375 if (ev.xclient.format == 32
1376 && ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1377 {
1233 && (Atom)ev.xclient.data.l[0] == xa[XA_WMDELETEWINDOW]) 1378 if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1234 destroy (); 1379 destroy ();
1380#if ENABLE_EWMH
1381 else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1382 XSendEvent (disp, ev.xclient.window = display->root,
1383 False, SubstructureRedirectMask | SubstructureNotifyMask,
1384 &ev);
1385#endif
1386 }
1387#if ENABLE_XEMBED
1388 else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1389 {
1390 if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
1391 focus_in ();
1392 else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
1393 focus_out ();
1394 }
1395#endif
1235#ifdef OFFIX_DND 1396#ifdef OFFIX_DND
1236 /* OffiX Dnd (drag 'n' drop) protocol */ 1397 /* OffiX Dnd (drag 'n' drop) protocol */
1237 else if (ev.xclient.message_type == xa[XA_DNDPROTOCOL] 1398 else if (ev.xclient.message_type == xa[XA_DNDPROTOCOL]
1238 && (ev.xclient.data.l[0] == DndFile 1399 && (ev.xclient.data.l[0] == DndFile
1239 || ev.xclient.data.l[0] == DndDir 1400 || ev.xclient.data.l[0] == DndDir
1240 || ev.xclient.data.l[0] == DndLink)) 1401 || ev.xclient.data.l[0] == DndLink))
1241 { 1402 {
1242 /* Get Dnd data */ 1403 /* Get Dnd data */
1243 Atom ActualType; 1404 Atom ActualType;
1244 int ActualFormat; 1405 int ActualFormat;
1245 unsigned char *data; 1406 unsigned char *data;
1246 unsigned long Size, RemainingBytes; 1407 unsigned long Size, RemainingBytes;
1247 1408
1248 XGetWindowProperty (display->display, display->root, 1409 XGetWindowProperty (disp, display->root,
1249 xa[XA_DNDSELECTION], 1410 xa[XA_DNDSELECTION],
1250 0L, 1000000L, 1411 0L, 1000000L,
1251 False, AnyPropertyType, 1412 False, AnyPropertyType,
1252 &ActualType, &ActualFormat, 1413 &ActualType, &ActualFormat,
1253 &Size, &RemainingBytes, 1414 &Size, &RemainingBytes,
1254 &data); 1415 &data);
1255 XChangeProperty (display->display, display->root, 1416 set_string_property (XA_CUT_BUFFER0, data);
1256 XA_CUT_BUFFER0, XA_STRING,
1257 8, PropModeReplace,
1258 data, STRLEN (data));
1259 XFree (data); 1417 XFree (data);
1260 selection_paste (display->root, XA_CUT_BUFFER0, True); 1418 selection_paste (display->root, XA_CUT_BUFFER0, true);
1261 XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime); 1419 XSetInputFocus (disp, display->root, RevertToNone, CurrentTime);
1262 } 1420 }
1263#endif /* OFFIX_DND */ 1421#endif /* OFFIX_DND */
1264 break; 1422 break;
1265 1423
1266 case MappingNotify: 1424 case MappingNotify:
… …
1291 break; 1449 break;
1292 } 1450 }
1293 break; 1451 break;
1294 1452
1295 case FocusIn: 1453 case FocusIn:
1296 if (!TermWin.focus) 1454 focus_in ();
1455 break;
1456
1457 case FocusOut:
1458 focus_out ();
1459 break;
1460
1461 case ConfigureNotify:
1462 if (ev.xconfigure.window == parent[0])
1297 { 1463 {
1298 TermWin.focus = 1; 1464 while (XCheckTypedWindowEvent (disp, ev.xconfigure.window, ConfigureNotify, &ev))
1299 want_refresh = 1; 1465 ;
1300#ifdef USE_XIM 1466
1301 if (Input_Context != NULL) 1467 if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1302 XSetICFocus (Input_Context);
1303#endif
1304#ifdef CURSOR_BLINK
1305 if (Options & Opt_cursorBlink)
1306 cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1307#endif
1308#ifdef OFF_FOCUS_FADING
1309 if (rs[Rs_fade])
1310 { 1468 {
1311 PixColors = PixColorsFocused; 1469 seen_resize = 1;
1312 set_colorfgbg (); 1470 resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1313 scr_clear ();
1314 scr_touch (true);
1315 } 1471 }
1316#endif
1317
1318 }
1319 break;
1320
1321 case FocusOut:
1322 if (TermWin.focus)
1323 {
1324 TermWin.focus = 0;
1325 want_refresh = 1;
1326#ifdef USE_XIM
1327 if (Input_Context != NULL)
1328 XUnsetICFocus (Input_Context);
1329#endif
1330#ifdef CURSOR_BLINK
1331 if (Options & Opt_cursorBlink)
1332 cursor_blink_ev.stop ();
1333 hidden_cursor = 0;
1334#endif
1335#ifdef OFF_FOCUS_FADING
1336 if (rs[Rs_fade])
1337 {
1338 PixColors = PixColorsUnFocused;
1339 set_colorfgbg ();
1340 scr_clear ();
1341 scr_touch (true);
1342 }
1343#endif
1344
1345 }
1346 break;
1347
1348 case ConfigureNotify:
1349 if (ev.xconfigure.window == TermWin.parent[0])
1350 {
1351 int height, width;
1352
1353 do
1354 { /* Wrap lots of configures into one */
1355 width = ev.xconfigure.width;
1356 height = ev.xconfigure.height;
1357 D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1358 }
1359 while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1360
1361 if (szHint.width != width || szHint.height != height)
1362 resize_all_windows (width, height, 1);
1363 1472
1364#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */ 1473#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1365 if (Options & Opt_transparent) 1474 if (OPTION (Opt_transparent))
1366 {
1367 check_our_parents (); 1475 check_our_parents ();
1368 if (am_transparent)
1369 want_refresh = want_full_refresh = 1;
1370 }
1371#endif 1476#endif
1372 } 1477 }
1373 break; 1478 break;
1374 1479
1375 case PropertyNotify: 1480 case PropertyNotify:
… …
1383 selection_clear (); 1488 selection_clear ();
1384 break; 1489 break;
1385 1490
1386 case SelectionNotify: 1491 case SelectionNotify:
1387 if (selection_wait == Sel_normal) 1492 if (selection_wait == Sel_normal)
1388 selection_paste (ev.xselection.requestor, 1493 selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1389 ev.xselection.property, True);
1390 break; 1494 break;
1391 1495
1392 case SelectionRequest: 1496 case SelectionRequest:
1393 selection_send (ev.xselectionrequest); 1497 selection_send (ev.xselectionrequest);
1394 break; 1498 break;
1395 1499
1396 case UnmapNotify: 1500 case UnmapNotify:
1397 TermWin.mapped = 0; 1501 mapped = 0;
1398#ifdef TEXT_BLINK 1502#ifdef TEXT_BLINK
1399 text_blink_ev.stop (); 1503 text_blink_ev.stop ();
1400#endif 1504#endif
1401 break; 1505 break;
1402 1506
1403 case MapNotify: 1507 case MapNotify:
1404 TermWin.mapped = 1; 1508 mapped = 1;
1405#ifdef TEXT_BLINK 1509#ifdef TEXT_BLINK
1406 text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL); 1510 text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
1407#endif 1511#endif
1408 break; 1512 break;
1409 1513
… …
1413 break; 1517 break;
1414#endif /* TRANSPARENT */ 1518#endif /* TRANSPARENT */
1415 1519
1416 case GraphicsExpose: 1520 case GraphicsExpose:
1417 case Expose: 1521 case Expose:
1418 if (ev.xany.window == TermWin.vt) 1522 if (ev.xany.window == vt)
1419 { 1523 {
1420 do 1524 do
1421 scr_expose (ev.xexpose.x, ev.xexpose.y, 1525 scr_expose (ev.xexpose.x, ev.xexpose.y,
1422 ev.xexpose.width, ev.xexpose.height, False); 1526 ev.xexpose.width, ev.xexpose.height, False);
1423 while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev)); 1527 while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev));
1424 1528
1425 ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose; 1529 ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
1426 1530
1427 while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev)) 1531 while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev))
1428 scr_expose (ev.xexpose.x, ev.xexpose.y, 1532 scr_expose (ev.xexpose.x, ev.xexpose.y,
1429 ev.xexpose.width, ev.xexpose.height, False); 1533 ev.xexpose.width, ev.xexpose.height, False);
1430 1534
1431 scr_refresh (refresh_type); 1535 scr_refresh (refresh_type);
1432 } 1536 }
1433 else 1537 else
1434 { 1538 {
1435 XEvent unused_event; 1539 XEvent unused_event;
1436 1540
1437 while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event)) 1541 while (XCheckTypedWindowEvent (disp, ev.xany.window, Expose, &unused_event))
1438 ; 1542 ;
1439 while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event)) 1543 while (XCheckTypedWindowEvent (disp, ev.xany.window, GraphicsExpose, &unused_event))
1440 ; 1544 ;
1441 1545
1442 if (isScrollbarWindow (ev.xany.window)) 1546 if (isScrollbarWindow (ev.xany.window))
1443 { 1547 {
1444 scrollBar.setIdle (); 1548 scrollBar.setIdle ();
… …
1448 if (menubar_visible () && isMenuBarWindow (ev.xany.window)) 1552 if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1449 menubar_expose (); 1553 menubar_expose ();
1450#endif 1554#endif
1451 1555
1452#ifdef TRANSPARENT 1556#ifdef TRANSPARENT
1453 if (am_transparent && ev.xany.window == TermWin.parent[0]) 1557 if (am_transparent && ev.xany.window == parent[0])
1454 XClearWindow (display->display, ev.xany.window); 1558 XClearWindow (disp, ev.xany.window);
1455#endif 1559#endif
1456 } 1560 }
1457 break; 1561 break;
1458 1562
1459 case MotionNotify: 1563 case MotionNotify:
… …
1466 { 1570 {
1467 menubar_control (ev.xbutton); 1571 menubar_control (ev.xbutton);
1468 break; 1572 break;
1469 } 1573 }
1470#endif 1574#endif
1471 if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate)) 1575 if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1472 break; 1576 break;
1473 1577
1474 if (ev.xany.window == TermWin.vt) 1578 if (ev.xany.window == vt)
1475 { 1579 {
1476 if ((ev.xbutton.state & (Button1Mask | Button3Mask))) 1580 if (ev.xbutton.state & (Button1Mask | Button3Mask))
1477 { 1581 {
1478 while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev)) 1582 while (XCheckTypedWindowEvent (disp, vt, MotionNotify, &ev))
1479 ; 1583 ;
1480 1584
1481 XQueryPointer (display->display, TermWin.vt, 1585 XQueryPointer (disp, vt,
1482 &unused_root, &unused_child, 1586 &unused_root, &unused_child,
1483 &unused_root_x, &unused_root_y, 1587 &unused_root_x, &unused_root_y,
1484 & (ev.xbutton.x), & (ev.xbutton.y), 1588 &ev.xbutton.x, &ev.xbutton.y,
1485 &unused_mask); 1589 &ev.xbutton.state);
1486#ifdef MOUSE_THRESHOLD 1590#ifdef MOUSE_THRESHOLD
1487 /* deal with a `jumpy' mouse */ 1591 /* deal with a `jumpy' mouse */
1488 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD) 1592 if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1489 { 1593 {
1490#endif 1594#endif
1595#if ISO_14755
1596 // 5.4
1597 if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1598 {
1599 iso14755_54 (ev.xbutton.x, ev.xbutton.y);
1600 break;
1601 }
1602#endif
1491 selection_extend ((ev.xbutton.x), (ev.xbutton.y), 1603 selection_extend (ev.xbutton.x, ev.xbutton.y,
1492 (ev.xbutton.state & Button3Mask) ? 2 : 0); 1604 ev.xbutton.state & Button3Mask ? 2 : 0);
1605
1493#ifdef SELECTION_SCROLLING 1606#ifdef SELECTION_SCROLLING
1494 if (ev.xbutton.y < TermWin.int_bwidth 1607 if (ev.xbutton.y < int_bwidth
1495 || Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1)) 1608 || Pixel2Row (ev.xbutton.y) > (nrow-1))
1496 { 1609 {
1497 int dist; 1610 int dist;
1498 1611
1499 /* don't clobber the current delay if we are 1612 /* don't clobber the current delay if we are
1500 * already in the middle of scrolling. 1613 * already in the middle of scrolling.
… …
1503 sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY); 1616 sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1504 1617
1505 /* save the event params so we can highlight 1618 /* save the event params so we can highlight
1506 * the selection in the pending-scroll loop 1619 * the selection in the pending-scroll loop
1507 */ 1620 */
1508 selection_save_x=ev.xbutton.x; 1621 selection_save_x = ev.xbutton.x;
1509 selection_save_y=ev.xbutton.y; 1622 selection_save_y = ev.xbutton.y;
1510 selection_save_state=
1511 (ev.xbutton.state & Button3Mask) ? 2 : 0; 1623 selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1512 1624
1513 /* calc number of lines to scroll */ 1625 /* calc number of lines to scroll */
1514 if (ev.xbutton.y<TermWin.int_bwidth) 1626 if (ev.xbutton.y < int_bwidth)
1515 { 1627 {
1516 scroll_selection_dir = UP; 1628 scroll_selection_dir = UP;
1517 dist = TermWin.int_bwidth - ev.xbutton.y; 1629 dist = int_bwidth - ev.xbutton.y;
1518 } 1630 }
1519 else 1631 else
1520 { 1632 {
1521 scroll_selection_dir = DN; 1633 scroll_selection_dir = DN;
1522 dist = ev.xbutton.y - 1634 dist = ev.xbutton.y - (int_bwidth + height);
1523 (TermWin.int_bwidth + TermWin.height);
1524 } 1635 }
1636
1525 scroll_selection_lines= (Pixel2Height (dist)/ 1637 scroll_selection_lines = Pixel2Height (dist)
1526 SELECTION_SCROLL_LINE_SPEEDUP)+1; 1638 / SELECTION_SCROLL_LINE_SPEEDUP
1639 + 1;
1527 MIN_IT (scroll_selection_lines, 1640 min_it (scroll_selection_lines,
1528 SELECTION_SCROLL_MAX_LINES); 1641 SELECTION_SCROLL_MAX_LINES);
1529 } 1642 }
1530 else 1643 else
1531 { 1644 {
1532 /* we are within the text window, so we 1645 /* we are within the text window, so we
1533 * shouldn't be scrolling 1646 * shouldn't be scrolling
… …
1535 if (sel_scroll_ev.active) 1648 if (sel_scroll_ev.active)
1536 sel_scroll_ev.stop(); 1649 sel_scroll_ev.stop();
1537 } 1650 }
1538#endif 1651#endif
1539#ifdef MOUSE_THRESHOLD 1652#ifdef MOUSE_THRESHOLD
1540
1541 } 1653 }
1542#endif 1654#endif
1543
1544 } 1655 }
1545 } 1656 }
1546 else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ()) 1657 else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1547 { 1658 {
1548 while (XCheckTypedWindowEvent (display->display, scrollBar.win, 1659 while (XCheckTypedWindowEvent (disp, scrollBar.win,
1549 MotionNotify, &ev)) ; 1660 MotionNotify, &ev))
1661 ;
1662
1550 XQueryPointer (display->display, scrollBar.win, 1663 XQueryPointer (disp, scrollBar.win,
1551 &unused_root, &unused_child, 1664 &unused_root, &unused_child,
1552 &unused_root_x, &unused_root_y, 1665 &unused_root_x, &unused_root_y,
1553 & (ev.xbutton.x), & (ev.xbutton.y), 1666 &ev.xbutton.x, &ev.xbutton.y,
1554 &unused_mask); 1667 &unused_mask);
1555 scr_move_to (scrollbar_position (ev.xbutton.y) - csrO, 1668 scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1556 scrollbar_size ()); 1669 scrollbar_size ());
1557 scr_refresh (refresh_type); 1670 scr_refresh (refresh_type);
1558 refresh_limit = 0; 1671 refresh_limit = 0;
… …
1560 } 1673 }
1561 break; 1674 break;
1562 } 1675 }
1563} 1676}
1564 1677
1678void
1679rxvt_term::focus_in ()
1680{
1681 if (!focus)
1682 {
1683 focus = 1;
1684 want_refresh = 1;
1685#if USE_XIM
1686 if (Input_Context != NULL)
1687 {
1688 IMSetStatusPosition ();
1689 XSetICFocus (Input_Context);
1690 }
1691#endif
1692#if CURSOR_BLINK
1693 if (OPTION (Opt_cursorBlink))
1694 cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1695#endif
1696#if OFF_FOCUS_FADING
1697 if (rs[Rs_fade])
1698 {
1699 pix_colors = pix_colors_focused;
1700 scr_recolour ();
1701 }
1702#endif
1703 }
1704}
1705
1706void
1707rxvt_term::focus_out ()
1708{
1709 if (focus)
1710 {
1711 focus = 0;
1712 want_refresh = 1;
1713
1714#if ENABLE_FRILLS || ISO_14755
1715 iso14755buf = 0;
1716#endif
1717#if ENABLE_OVERLAY
1718 scr_overlay_off ();
1719#endif
1720#if USE_XIM
1721 if (Input_Context != NULL)
1722 XUnsetICFocus (Input_Context);
1723#endif
1724#if CURSOR_BLINK
1725 if (OPTION (Opt_cursorBlink))
1726 cursor_blink_ev.stop ();
1727 hidden_cursor = 0;
1728#endif
1729#if OFF_FOCUS_FADING
1730 if (rs[Rs_fade])
1731 {
1732 pix_colors = pix_colors_unfocused;
1733 scr_recolour ();
1734 }
1735#endif
1736 }
1737}
1738
1565#if TRANSPARENT 1739#if TRANSPARENT
1566void 1740void
1567rxvt_term::rootwin_cb (XEvent &ev) 1741rxvt_term::rootwin_cb (XEvent &ev)
1568{ 1742{
1569 SET_R (this); 1743 SET_R (this);
… …
1574 case PropertyNotify: 1748 case PropertyNotify:
1575 /* 1749 /*
1576 * if user used some Esetroot compatible prog to set the root bg, 1750 * if user used some Esetroot compatible prog to set the root bg,
1577 * use the property to determine the pixmap. We use it later on. 1751 * use the property to determine the pixmap. We use it later on.
1578 */ 1752 */
1579 if (xa[XA_XROOTPMAPID] == 0)
1580 xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1581
1582 if (ev.xproperty.atom != xa[XA_XROOTPMAPID]) 1753 if (ev.xproperty.atom != xa[XA_XROOTPMAP_ID]
1754 && ev.xproperty.atom != xa[XA_ESETROOT_PMAP_ID])
1583 return; 1755 return;
1584 1756
1585 /* FALLTHROUGH */ 1757 /* FALLTHROUGH */
1586 case ReparentNotify: 1758 case ReparentNotify:
1587 if ((Options & Opt_transparent) && check_our_parents () && am_transparent) 1759 if (OPTION (Opt_transparent) && check_our_parents () && am_transparent)
1588 want_refresh = want_full_refresh = 1; 1760 want_refresh = want_full_refresh = 1;
1589 break; 1761 break;
1590 } 1762 }
1591} 1763}
1592#endif 1764#endif
… …
1596{ 1768{
1597 int reportmode = 0, clickintime; 1769 int reportmode = 0, clickintime;
1598 1770
1599 bypass_keystate = ev.state & (ModMetaMask | ShiftMask); 1771 bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1600 if (!bypass_keystate) 1772 if (!bypass_keystate)
1601 reportmode = !! (PrivateModes & PrivMode_mouse_report); 1773 reportmode = !! (priv_modes & PrivMode_mouse_report);
1774
1602 /* 1775 /*
1603 * VT window processing of button press 1776 * VT window processing of button press
1604 */ 1777 */
1605 if (ev.window == TermWin.vt) 1778 if (ev.window == vt)
1606 { 1779 {
1780#if ISO_14755
1781 // 5.4
1782 if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1783 {
1784 iso14755_54 (ev.x, ev.y);
1785 return;
1786 }
1787#endif
1788
1607 clickintime = ev.time - MEvent.time < MULTICLICK_TIME; 1789 clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1790
1608 if (reportmode) 1791 if (reportmode)
1609 { 1792 {
1610 /* mouse report from vt window */ 1793 /* mouse report from vt window */
1611 /* save the xbutton state (for ButtonRelease) */ 1794 /* save the xbutton state (for ButtonRelease) */
1612 MEvent.state = ev.state; 1795 MEvent.state = ev.state;
… …
1641 } 1824 }
1642 else 1825 else
1643 { 1826 {
1644 if (ev.button != MEvent.button) 1827 if (ev.button != MEvent.button)
1645 MEvent.clicks = 0; 1828 MEvent.clicks = 0;
1829
1646 switch (ev.button) 1830 switch (ev.button)
1647 { 1831 {
1648 case Button1: 1832 case Button1:
1833 /* allow meta + click to select rectangular areas */
1834 /* should be done in screen.C */
1835#if ENABLE_FRILLS
1836 selection.rect = !!(ev.state & ModMetaMask);
1837#else
1838 selection.rect = false;
1839#endif
1840
1649 /* allow shift+left click to extend selection */ 1841 /* allow shift+left click to extend selection */
1650 if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report)) 1842 if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1651 { 1843 {
1652 if (MEvent.button == Button1 && clickintime) 1844 if (MEvent.button == Button1 && clickintime)
1653 selection_rotate (ev.x, ev.y); 1845 selection_rotate (ev.x, ev.y);
1654 else 1846 else
1655 selection_extend (ev.x, ev.y, 1); 1847 selection_extend (ev.x, ev.y, 1);
… …
1670 case Button3: 1862 case Button3:
1671 if (MEvent.button == Button3 && clickintime) 1863 if (MEvent.button == Button3 && clickintime)
1672 selection_rotate (ev.x, ev.y); 1864 selection_rotate (ev.x, ev.y);
1673 else 1865 else
1674 selection_extend (ev.x, ev.y, 1); 1866 selection_extend (ev.x, ev.y, 1);
1867
1675 MEvent.button = Button3; 1868 MEvent.button = Button3;
1676 break; 1869 break;
1677 } 1870 }
1678 } 1871 }
1872
1679 MEvent.time = ev.time; 1873 MEvent.time = ev.time;
1680 return; 1874 return;
1681 } 1875 }
1682 1876
1683 /* 1877 /*
… …
1794 case Button3: 1988 case Button3:
1795 if (scrollBar.style != R_SB_XTERM) 1989 if (scrollBar.style != R_SB_XTERM)
1796 { 1990 {
1797 if (scrollbar_above_slider (ev.y)) 1991 if (scrollbar_above_slider (ev.y))
1798# ifdef RXVT_SCROLL_FULL 1992# ifdef RXVT_SCROLL_FULL
1799 scr_page (UP, TermWin.nrow - 1); 1993 scr_page (UP, nrow - 1);
1800# else 1994# else
1801 scr_page (UP, TermWin.nrow / 4); 1995 scr_page (UP, nrow / 4);
1802# endif 1996# endif
1803 else if (scrollbar_below_slider (ev.y)) 1997 else if (scrollbar_below_slider (ev.y))
1804# ifdef RXVT_SCROLL_FULL 1998# ifdef RXVT_SCROLL_FULL
1805 scr_page (DN, TermWin.nrow - 1); 1999 scr_page (DN, nrow - 1);
1806# else 2000# else
1807 scr_page (DN, TermWin.nrow / 4); 2001 scr_page (DN, nrow / 4);
1808# endif 2002# endif
1809 else 2003 else
1810 scrollBar.setMotion (); 2004 scrollBar.setMotion ();
1811 } 2005 }
1812 else 2006 else
1813 { 2007 {
1814 scr_page ((ev.button == Button1 ? DN : UP), 2008 scr_page ((ev.button == Button1 ? DN : UP),
1815 (TermWin.nrow 2009 (nrow
1816 * scrollbar_position (ev.y) 2010 * scrollbar_position (ev.y)
1817 / scrollbar_size ())); 2011 / scrollbar_size ()));
1818 } 2012 }
1819 2013
1820 break; 2014 break;
… …
1836{ 2030{
1837 int reportmode = 0; 2031 int reportmode = 0;
1838 2032
1839 csrO = 0; /* reset csr Offset */ 2033 csrO = 0; /* reset csr Offset */
1840 if (!bypass_keystate) 2034 if (!bypass_keystate)
1841 reportmode = !! (PrivateModes & PrivMode_mouse_report); 2035 reportmode = !! (priv_modes & PrivMode_mouse_report);
1842 2036
1843 if (scrollbar_isUpDn ()) 2037 if (scrollbar_isUpDn ())
1844 { 2038 {
1845 scrollBar.setIdle (); 2039 scrollBar.setIdle ();
1846 scrollbar_show (0); 2040 scrollbar_show (0);
1847#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING 2041#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1848 refresh_type &= ~SMOOTH_REFRESH; 2042 refresh_type &= ~SMOOTH_REFRESH;
1849#endif 2043#endif
1850
1851 } 2044 }
2045
1852#ifdef SELECTION_SCROLLING 2046#ifdef SELECTION_SCROLLING
1853 if (sel_scroll_ev.active) 2047 if (sel_scroll_ev.active)
1854 sel_scroll_ev.stop(); 2048 sel_scroll_ev.stop();
1855#endif 2049#endif
2050
1856 if (ev.window == TermWin.vt) 2051 if (ev.window == vt)
1857 { 2052 {
2053#if ISO_14755
2054 // 5.4
2055 if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
2056 return;
2057#endif
1858 if (reportmode) 2058 if (reportmode)
1859 { 2059 {
1860 /* mouse report from vt window */ 2060 /* mouse report from vt window */
1861 /* don't report release of wheel "buttons" */ 2061 /* don't report release of wheel "buttons" */
1862 if (ev.button >= 4) 2062 if (ev.button >= 4)
… …
1876 MEvent.button = AnyButton; 2076 MEvent.button = AnyButton;
1877 mouse_report (ev); 2077 mouse_report (ev);
1878#endif /* MOUSE_REPORT_DOUBLECLICK */ 2078#endif /* MOUSE_REPORT_DOUBLECLICK */
1879 return; 2079 return;
1880 } 2080 }
2081
1881 /* 2082 /*
1882 * dumb hack to compensate for the failure of click-and-drag 2083 * dumb hack to compensate for the failure of click-and-drag
1883 * when overriding mouse reporting 2084 * when overriding mouse reporting
1884 */ 2085 */
1885 if (PrivateModes & PrivMode_mouse_report 2086 if (priv_modes & PrivMode_mouse_report
1886 && bypass_keystate 2087 && bypass_keystate
1887 && ev.button == Button1 && MEvent.clicks <= 1) 2088 && ev.button == Button1 && MEvent.clicks <= 1)
1888 selection_extend (ev.x, ev.y, 0); 2089 selection_extend (ev.x, ev.y, 0);
1889 2090
1890 switch (ev.button) 2091 switch (ev.button)
… …
1905 2106
1906 v = ev.button == Button4 ? UP : DN; 2107 v = ev.button == Button4 ? UP : DN;
1907 2108
1908 if (ev.state & ShiftMask) 2109 if (ev.state & ShiftMask)
1909 i = 1; 2110 i = 1;
1910 else if (Options & Opt_mouseWheelScrollPage) 2111 else if (OPTION (Opt_mouseWheelScrollPage))
1911 i = TermWin.nrow - 1; 2112 i = nrow - 1;
1912 else 2113 else
1913 i = 5; 2114 i = 5;
1914 2115
1915# ifdef MOUSE_SLIP_WHEELING 2116# ifdef MOUSE_SLIP_WHEELING
1916 if (ev.state & ControlMask) 2117 if (ev.state & ControlMask)
1917 { 2118 {
1918 mouse_slip_wheel_speed += v ? -1 : 1; 2119 mouse_slip_wheel_speed += v ? -1 : 1;
1919 if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow; 2120 if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
1920 if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow; 2121 if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
1921 2122
1922 if (slip_wheel_ev.at < NOW) 2123 if (slip_wheel_ev.at < NOW)
1923 slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY; 2124 slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
1924 2125
1925 slip_wheel_ev.start (); 2126 slip_wheel_ev.start ();
… …
1966 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b; 2167 RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1967 unsigned int lower_lim_r, lower_lim_g, lower_lim_b; 2168 unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
1968 unsigned int upper_lim_r, upper_lim_g, upper_lim_b; 2169 unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
1969 int i; 2170 int i;
1970 2171
1971 Visual* visual = display->visual; 2172 Visual *visual = display->visual;
1972 2173
1973 if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ; 2174 if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
1974 2175
1975 /* for convenience */ 2176 /* for convenience */
1976 mask_r = visual->red_mask; 2177 mask_r = visual->red_mask;
… …
2197 Atom atype; 2398 Atom atype;
2198 unsigned char *prop = NULL; 2399 unsigned char *prop = NULL;
2199 Window root, oldp, *list; 2400 Window root, oldp, *list;
2200 Pixmap rootpixmap = None; 2401 Pixmap rootpixmap = None;
2201 XWindowAttributes wattr, wrootattr; 2402 XWindowAttributes wattr, wrootattr;
2403 dDisp;
2202 2404
2203 pchanged = 0; 2405 pchanged = 0;
2204 2406
2205 if (!(Options & Opt_transparent)) 2407 if (!OPTION (Opt_transparent))
2206 return pchanged; /* Don't try any more */ 2408 return pchanged; /* Don't try any more */
2207 2409
2208 XGetWindowAttributes (display->display, display->root, &wrootattr); 2410 XGetWindowAttributes (disp, display->root, &wrootattr);
2209 rootdepth = wrootattr.depth; 2411 rootdepth = wrootattr.depth;
2210 2412
2211 XGetWindowAttributes (display->display, TermWin.parent[0], &wattr); 2413 XGetWindowAttributes (disp, parent[0], &wattr);
2212 2414
2213 if (rootdepth != wattr.depth) 2415 if (rootdepth != wattr.depth)
2214 { 2416 {
2215 if (am_transparent) 2417 if (am_transparent)
2216 { 2418 {
2217 pchanged = 1; 2419 pchanged = 1;
2218 XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]); 2420 XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
2219 am_transparent = am_pixmap_trans = 0; 2421 am_transparent = am_pixmap_trans = 0;
2220 } 2422 }
2221 2423
2222 return pchanged; /* Don't try any more */ 2424 return pchanged; /* Don't try any more */
2223 } 2425 }
2224 2426
2225 /* Get all X ops out of the queue so that our information is up-to-date. */ 2427 /* Get all X ops out of the queue so that our information is up-to-date. */
2226 XSync (display->display, False); 2428 XSync (disp, False);
2227 2429
2228 /* 2430 /*
2229 * Make the frame window set by the window manager have 2431 * Make the frame window set by the window manager have
2230 * the root background. Some window managers put multiple nested frame 2432 * the root background. Some window managers put multiple nested frame
2231 * windows for each client, so we have to take care about that. 2433 * windows for each client, so we have to take care about that.
2232 */ 2434 */
2233 i = (xa[XA_XROOTPMAPID] 2435 i = (xa[XA_XROOTPMAP_ID]
2234 && XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID], 2436 && XGetWindowProperty (disp, display->root, xa[XA_XROOTPMAP_ID],
2235 0L, 1L, False, XA_PIXMAP, &atype, &aformat, 2437 0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2236 &nitems, &bytes_after, &prop) == Success); 2438 &nitems, &bytes_after, &prop) == Success);
2237 2439
2238 if (!i || prop == NULL) 2440 if (!i || prop == NULL)
2239 i = (xa[XA_XSETROOTID] 2441 i = (xa[XA_ESETROOT_PMAP_ID]
2240 && XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID], 2442 && XGetWindowProperty (disp, display->root, xa[XA_ESETROOT_PMAP_ID],
2241 0L, 1L, False, XA_PIXMAP, &atype, &aformat, 2443 0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2242 &nitems, &bytes_after, &prop) == Success); 2444 &nitems, &bytes_after, &prop) == Success);
2243 2445
2244 if (!i || prop == NULL 2446 if (!i || prop == NULL
2245#if TINTING 2447#if TINTING
… …
2264 Window cr; 2466 Window cr;
2265 XImage *image; 2467 XImage *image;
2266 GC gc; 2468 GC gc;
2267 XGCValues gcvalue; 2469 XGCValues gcvalue;
2268 2470
2269 XTranslateCoordinates (display->display, TermWin.parent[0], display->root, 2471 XTranslateCoordinates (disp, parent[0], display->root,
2270 0, 0, &sx, &sy, &cr); 2472 0, 0, &sx, &sy, &cr);
2271 nw = (unsigned int)szHint.width; 2473 nw = (unsigned int)szHint.width;
2272 nh = (unsigned int)szHint.height; 2474 nh = (unsigned int)szHint.height;
2273 nx = ny = 0; 2475 nx = ny = 0;
2274 2476
… …
2284 nh += sy; 2486 nh += sy;
2285 ny = -sy; 2487 ny = -sy;
2286 sy = 0; 2488 sy = 0;
2287 } 2489 }
2288 2490
2289 MIN_IT (nw, (unsigned int) (wrootattr.width - sx)); 2491 min_it (nw, (unsigned int) (wrootattr.width - sx));
2290 MIN_IT (nh, (unsigned int) (wrootattr.height - sy)); 2492 min_it (nh, (unsigned int) (wrootattr.height - sy));
2493
2494 XSync (disp, False);
2291 allowedxerror = -1; 2495 allowedxerror = -1;
2292 image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap); 2496 image = XGetImage (disp, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
2293 2497
2294 /* XXX: handle BadMatch - usually because we're outside the pixmap */ 2498 /* XXX: handle BadMatch - usually because we're outside the pixmap */
2295 /* XXX: may need a delay here? */ 2499 /* XXX: may need a delay here? */
2296 allowedxerror = 0; 2500 allowedxerror = 0;
2297 2501
2298 if (image == NULL) 2502 if (image == NULL)
2299 { 2503 {
2300 if (am_transparent && am_pixmap_trans) 2504 if (am_transparent && am_pixmap_trans)
2301 { 2505 {
2302 pchanged = 1; 2506 pchanged = 1;
2303 if (TermWin.pixmap != None) 2507 if (pixmap != None)
2304 { 2508 {
2305 XFreePixmap (display->display, TermWin.pixmap); 2509 XFreePixmap (disp, pixmap);
2306 TermWin.pixmap = None; 2510 pixmap = None;
2307 } 2511 }
2308 } 2512 }
2309 2513
2310 am_pixmap_trans = 0; 2514 am_pixmap_trans = 0;
2311 } 2515 }
2312 else 2516 else
2313 { 2517 {
2314 if (TermWin.pixmap != None) 2518 if (pixmap != None)
2315 XFreePixmap (display->display, TermWin.pixmap); 2519 XFreePixmap (disp, pixmap);
2316 2520
2317#if TINTING 2521#if TINTING
2318 if (ISSET_PIXCOLOR (Color_tint)) 2522 if (ISSET_PIXCOLOR (Color_tint))
2319 { 2523 {
2320 unsigned short rm, gm, bm; 2524 unsigned short rm, gm, bm;
2321 int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100; 2525 int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2322 2526
2323 PixColorsFocused[Color_tint].get (display, rm, gm, bm); 2527 pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2324 2528
2325 ShadeXImage (display, image, shade, rm, gm, bm); 2529 ShadeXImage (display, image, shade, rm, gm, bm);
2326 } 2530 }
2327#endif 2531#endif
2328 2532
2329 TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt, 2533 pixmap = XCreatePixmap (disp, vt,
2330 szHint.width, szHint.height, image->depth); 2534 szHint.width, szHint.height, image->depth);
2331 gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue); 2535 gc = XCreateGC (disp, vt, 0UL, &gcvalue);
2332 XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0, 2536 XPutImage (disp, pixmap, gc, image, 0, 0,
2333 nx, ny, image->width, image->height); 2537 nx, ny, image->width, image->height);
2334 XFreeGC (display->display, gc); 2538 XFreeGC (disp, gc);
2335 XDestroyImage (image); 2539 XDestroyImage (image);
2336 XSetWindowBackgroundPixmap (display->display, TermWin.parent[0], TermWin.pixmap); 2540 XSetWindowBackgroundPixmap (disp, parent[0], pixmap);
2337 XClearWindow (display->display, TermWin.parent[0]); 2541 XClearWindow (disp, parent[0]);
2338 2542
2339 if (!am_transparent || !am_pixmap_trans) 2543 if (!am_transparent || !am_pixmap_trans)
2340 pchanged = 1; 2544 pchanged = 1;
2341 2545
2342 am_transparent = am_pixmap_trans = 1; 2546 am_transparent = am_pixmap_trans = 1;
2343 } 2547 }
2344 } 2548 }
2345 2549
2346 if (!am_pixmap_trans) 2550 if (am_pixmap_trans)
2551 XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
2552 else
2347 { 2553 {
2348 unsigned int n; 2554 unsigned int n;
2349 /* 2555 /*
2350 * InheritPixmap transparency 2556 * InheritPixmap transparency
2351 */ 2557 */
2352 D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2353 for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++) 2558 for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
2354 { 2559 {
2355 oldp = TermWin.parent[i]; 2560 oldp = parent[i];
2356 XQueryTree (display->display, TermWin.parent[i - 1], &root, 2561 XQueryTree (disp, parent[i - 1], &root,
2357 &TermWin.parent[i], &list, &n); 2562 &parent[i], &list, &n);
2358 XFree (list); 2563 XFree (list);
2359 D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2360 2564
2361 if (TermWin.parent[i] == display->root) 2565 if (parent[i] == display->root)
2362 { 2566 {
2363 if (oldp != None) 2567 if (oldp != None)
2364 pchanged = 1; 2568 pchanged = 1;
2365 2569
2366 break; 2570 break;
2367 } 2571 }
2368 2572
2369 if (oldp != TermWin.parent[i]) 2573 if (oldp != parent[i])
2370 pchanged = 1; 2574 pchanged = 1;
2371 } 2575 }
2372 2576
2373 n = 0; 2577 n = 0;
2374 2578
2375 if (pchanged) 2579 if (pchanged)
2376 { 2580 {
2377 for (; n < (unsigned int)i; n++) 2581 for (; n < (unsigned int)i; n++)
2378 { 2582 {
2379 XGetWindowAttributes (display->display, TermWin.parent[n], &wattr); 2583 XGetWindowAttributes (disp, parent[n], &wattr);
2380 D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2381 if (wattr.depth != rootdepth || wattr.c_class == InputOnly) 2584 if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2382 { 2585 {
2383 n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1; 2586 n = (int) (sizeof (parent) / sizeof (Window)) + 1;
2384 break; 2587 break;
2385 } 2588 }
2386 } 2589 }
2387 } 2590 }
2388 2591
2389 if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0]))) 2592 if (n > (int) (sizeof (parent) / sizeof (parent[0])))
2390 { 2593 {
2391 D_X ((stderr, "InheritPixmap Turning off"));
2392 XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]); 2594 XSetWindowBackground (disp, parent[0], pix_colors_focused[Color_border]);
2393 XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]); 2595 XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
2394 am_transparent = 0; 2596 am_transparent = 0;
2395 /* XXX: also turn off Opt_transparent? */ 2597 /* XXX: also turn off Opt_transparent? */
2396 } 2598 }
2397 else 2599 else
2398 { 2600 {
2399#if WAIT_FOR_WM 2601#if WAIT_FOR_WM
2400 /* wait (an arbitrary period) for the WM to do its thing 2602 /* wait (an arbitrary period) for the WM to do its thing
2401 * needed for fvwm2.2.2 (and before?) */ 2603 * needed for fvwm2.2.2 (and before?) */
2402 sleep (1); 2604 sleep (1);
2403#endif 2605#endif
2404 D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2405 for (n = 0; n < (unsigned int)i; n++) 2606 for (n = 0; n < (unsigned int)i; n++)
2406 { 2607 {
2407 XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative); 2608 XSetWindowBackgroundPixmap (disp, parent[n], ParentRelative);
2408 XClearWindow (display->display, TermWin.parent[n]); 2609 XClearWindow (disp, parent[n]);
2409 } 2610 }
2410 2611
2411 XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative); 2612 XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
2412 am_transparent = 1; 2613 am_transparent = 1;
2413 } 2614 }
2414 2615
2415 for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++) 2616 for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
2416 TermWin.parent[i] = None; 2617 parent[i] = None;
2417 } 2618 }
2418 2619
2419 // this is experimental
2420 if (scrollBar.win) 2620 if (scrollBar.win)
2421 { 2621 {
2422 XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative); 2622 XSetWindowBackgroundPixmap (disp, scrollBar.win, ParentRelative);
2423 XClearWindow (display->display, scrollBar.win);
2424 scrollBar.setIdle (); 2623 scrollBar.setIdle ();
2425 scrollbar_show (0); 2624 scrollbar_show (0);
2625 }
2626
2627 if (am_transparent)
2628 {
2629 want_refresh = want_full_refresh = 1;
2630 if (am_pixmap_trans)
2631 flush ();
2426 } 2632 }
2427 2633
2428 return pchanged; 2634 return pchanged;
2429} 2635}
2430#endif 2636#endif
… …
2449 if (ch == NOCHAR) // TODO: improve 2655 if (ch == NOCHAR) // TODO: improve
2450 break; 2656 break;
2451 2657
2452 if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT) 2658 if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2453 { 2659 {
2660 if (!seen_input)
2661 {
2662 seen_input = 1;
2663 // many badly-written programs (e.g. jed) contain a race condition:
2664 // they first read the screensize and then install a SIGWINCH handler.
2665 // some window managers resize the window early, and these programs
2666 // then sometimes get the size wrong.
2667 // unfortunately other programs are even more buggy and dislike
2668 // being sent SIGWINCH, so only do it when we were in fact being
2669 // resized.
2670 if (seen_resize && cmd_pid)
2671 kill (-cmd_pid, SIGWINCH);
2672 }
2673
2454 /* Read a text string from the input buffer */ 2674 /* Read a text string from the input buffer */
2455 unicode_t buf[UBUFSIZ]; 2675 unicode_t buf[UBUFSIZ];
2456 bool refreshnow = false; 2676 bool refreshnow = false;
2457 int nlines = 0; 2677 int nlines = 0;
2458 unicode_t *str = buf; 2678 unicode_t *str = buf;
2679 unicode_t *eol = str + min (ncol, UBUFSIZ);
2459 2680
2460 for (;;) 2681 for (;;)
2461 { 2682 {
2462 if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT)) 2683 if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2463 break; 2684 break;
2464 2685
2465 *str++ = ch; 2686 *str++ = ch;
2466 2687
2467 if (ch == C0_LF) 2688 if (ch == C0_LF || str >= eol)
2468 { 2689 {
2690 if (ch == C0_LF)
2469 nlines++; 2691 nlines++;
2692
2470 refresh_count++; 2693 refresh_count++;
2471 2694
2472 if (!(Options & Opt_jumpScroll) 2695 if (!OPTION (Opt_jumpScroll)
2473 || (refresh_count >= refresh_limit * (TermWin.nrow - 1))) 2696 || (refresh_count >= refresh_limit * (nrow - 1)))
2474 { 2697 {
2475 refreshnow = true; 2698 refreshnow = true;
2476 ch = NOCHAR; 2699 ch = NOCHAR;
2477 break; 2700 break;
2478 } 2701 }
2479 2702
2480 // scr_add_lines only works for nlines <= TermWin.nrow - 1. 2703 // scr_add_lines only works for nlines <= nrow - 1.
2481 if (nlines >= TermWin.nrow - 1) 2704 if (nlines >= nrow - 1)
2482 { 2705 {
2483 scr_add_lines (buf, nlines, str - buf); 2706 scr_add_lines (buf, nlines, str - buf);
2484 nlines = 0; 2707 nlines = 0;
2485 str = buf; 2708 str = buf;
2709 eol = str + min (ncol, UBUFSIZ);
2486 } 2710 }
2487 }
2488 2711
2489 if (str >= buf + UBUFSIZ) 2712 if (str >= eol)
2490 { 2713 {
2714 if (eol >= buf + UBUFSIZ)
2715 {
2491 ch = NOCHAR; 2716 ch = NOCHAR;
2492 break; 2717 break;
2718 }
2719 else
2720 eol = min (eol + ncol, buf + UBUFSIZ);
2721 }
2722
2493 } 2723 }
2494 2724
2495 seq_begin = cmdbuf_ptr; 2725 seq_begin = cmdbuf_ptr;
2496 ch = next_char (); 2726 ch = next_char ();
2497 } 2727 }
… …
2504 * the number of pages between refreshes is refresh_limit, which 2734 * the number of pages between refreshes is refresh_limit, which
2505 * is incremented here because we must be doing flat-out scrolling. 2735 * is incremented here because we must be doing flat-out scrolling.
2506 */ 2736 */
2507 if (refreshnow) 2737 if (refreshnow)
2508 { 2738 {
2509 if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD) 2739 if (OPTION (Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2510 refresh_limit++; 2740 refresh_limit++;
2511 else 2741 else
2512 { 2742 {
2513 flag = true; 2743 flag = true;
2514 scr_refresh (refresh_type); 2744 scr_refresh (refresh_type);
… …
2568 if (len == (size_t)-1) 2798 if (len == (size_t)-1)
2569 return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through 2799 return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2570 2800
2571 // assume wchar == unicode 2801 // assume wchar == unicode
2572 cmdbuf_ptr += len; 2802 cmdbuf_ptr += len;
2573 return wc; 2803 return wc & UNICODE_MASK;
2574 } 2804 }
2575 2805
2576 return NOCHAR; 2806 return NOCHAR;
2577} 2807}
2578 2808
… …
2704 process_escape_seq (); 2934 process_escape_seq ();
2705 break; 2935 break;
2706 case C0_ENQ: /* terminal Status */ 2936 case C0_ENQ: /* terminal Status */
2707 if (rs[Rs_answerbackstring]) 2937 if (rs[Rs_answerbackstring])
2708 tt_write ((const unsigned char *)rs[Rs_answerbackstring], 2938 tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2709 (unsigned int)STRLEN (rs[Rs_answerbackstring])); 2939 (unsigned int)strlen (rs[Rs_answerbackstring]));
2710 else 2940 else
2711 tt_write ((unsigned char *)VT100_ANS, 2941 tt_write ((unsigned char *)VT100_ANS,
2712 (unsigned int)STRLEN (VT100_ANS)); 2942 (unsigned int)strlen (VT100_ANS));
2713 break; 2943 break;
2714 case C0_BEL: /* bell */ 2944 case C0_BEL: /* bell */
2715 scr_bell (); 2945 scr_bell ();
2716 break; 2946 break;
2717 case C0_BS: /* backspace */ 2947 case C0_BS: /* backspace */
… …
2816void 3046void
2817rxvt_term::process_escape_seq () 3047rxvt_term::process_escape_seq ()
2818{ 3048{
2819 unicode_t ch = cmd_getc (); 3049 unicode_t ch = cmd_getc ();
2820 3050
2821 if (PrivateModes & PrivMode_vt52) 3051 if (priv_modes & PrivMode_vt52)
2822 { 3052 {
2823 process_escape_vt52 (ch); 3053 process_escape_vt52 (ch);
2824 return; 3054 return;
2825 } 3055 }
2826 3056
… …
2841 scr_charset_set (2, (unsigned int)cmd_getc ()); 3071 scr_charset_set (2, (unsigned int)cmd_getc ());
2842 break; 3072 break;
2843 case '+': 3073 case '+':
2844 scr_charset_set (3, (unsigned int)cmd_getc ()); 3074 scr_charset_set (3, (unsigned int)cmd_getc ());
2845 break; 3075 break;
2846#ifndef NO_FRILLS 3076#if ENABLE_FRILLS
2847 case '6': 3077 case '6':
2848 scr_backindex (); 3078 scr_backindex ();
2849 break; 3079 break;
2850#endif 3080#endif
2851 case '7': 3081 case '7':
2852 scr_cursor (SAVE); 3082 scr_cursor (SAVE);
2853 break; 3083 break;
2854 case '8': 3084 case '8':
2855 scr_cursor (RESTORE); 3085 scr_cursor (RESTORE);
2856 break; 3086 break;
2857#ifndef NO_FRILLS 3087#if ENABLE_FRILLS
2858 case '9': 3088 case '9':
2859 scr_forwardindex (); 3089 scr_forwardindex ();
2860 break; 3090 break;
2861#endif 3091#endif
2862 case '=': 3092 case '=':
… …
3041 { 3271 {
3042 switch (priv) 3272 switch (priv)
3043 { 3273 {
3044 case '>': 3274 case '>':
3045 if (ch == CSI_DA) /* secondary device attributes */ 3275 if (ch == CSI_DA) /* secondary device attributes */
3046 tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING); 3276 tt_printf ("\033[>%d;%c%c;0c", 'U', VERSION[0], VERSION[2]);
3047 break; 3277 break;
3048 case '?': 3278 case '?':
3049 if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't') 3279 if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
3050 process_terminal_mode (ch, priv, nargs, arg); 3280 process_terminal_mode (ch, priv, nargs, arg);
3051 break; 3281 break;
… …
3156 3386
3157 case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */ 3387 case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */
3158 arg[0] = -arg[0]; 3388 arg[0] = -arg[0];
3159 /* FALLTHROUGH */ 3389 /* FALLTHROUGH */
3160 case CSI_SU: /* 8.3.148: (1) SCROLL UP */ 3390 case CSI_SU: /* 8.3.148: (1) SCROLL UP */
3161 scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0); 3391 scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
3162 break; 3392 break;
3163 3393
3164 case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */ 3394 case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
3165 tt_write ((const unsigned char *)VT100_ANS, 3395 tt_write ((const unsigned char *)VT100_ANS,
3166 (unsigned int) (sizeof (VT100_ANS) - 1)); 3396 (unsigned int) (sizeof (VT100_ANS) - 1));
3167 break; 3397 break;
3168 3398
3169 case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */ 3399 case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
3170 process_sgr_mode (nargs, arg); 3400 process_sgr_mode (nargs, arg);
3171 break; 3401 break;
… …
3178 break; 3408 break;
3179 case 6: /* CPR requested */ 3409 case 6: /* CPR requested */
3180 scr_report_position (); 3410 scr_report_position ();
3181 break; 3411 break;
3182 case 7: /* unofficial extension */ 3412 case 7: /* unofficial extension */
3183 if (Options & Opt_insecure) 3413 if (OPTION (Opt_insecure))
3184 tt_printf ("%-.250s\n", rs[Rs_display_name]); 3414 tt_printf ("%-.250s\012", rs[Rs_display_name]);
3185 break; 3415 break;
3186 case 8: /* unofficial extension */ 3416 case 8: /* unofficial extension */
3187 process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST); 3417 process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3188 break; 3418 break;
3189 } 3419 }
… …
3225 break; 3455 break;
3226 3456
3227 case CSI_RM: /* 8.3.107: RESET MODE */ 3457 case CSI_RM: /* 8.3.107: RESET MODE */
3228 if (arg[0] == 4) 3458 if (arg[0] == 4)
3229 scr_insert_mode (0); 3459 scr_insert_mode (0);
3460 else if (arg[0] == 20)
3461 priv_modes &= ~PrivMode_LFNL;
3230 break; 3462 break;
3231 3463
3232 case CSI_SM: /* 8.3.126: SET MODE */ 3464 case CSI_SM: /* 8.3.126: SET MODE */
3233 if (arg[0] == 4) 3465 if (arg[0] == 4)
3234 scr_insert_mode (1); 3466 scr_insert_mode (1);
3467 else if (arg[0] == 20)
3468 priv_modes |= PrivMode_LFNL;
3235 break; 3469 break;
3236 3470
3237 /* 3471 /*
3238 * PRIVATE USE beyond this point. All CSI_7? sequences here 3472 * PRIVATE USE beyond this point. All CSI_7? sequences here
3239 */ 3473 */
… …
3251 break; 3485 break;
3252 case CSI_75: 3486 case CSI_75:
3253 scr_cursor (RESTORE); 3487 scr_cursor (RESTORE);
3254 break; 3488 break;
3255 3489
3256#ifndef NO_FRILLS 3490#if ENABLE_FRILLS
3257 case CSI_74: 3491 case CSI_74:
3258 process_window_ops (arg, nargs); 3492 process_window_ops (arg, nargs);
3259 break; 3493 break;
3260#endif 3494#endif
3261 3495
… …
3268 break; 3502 break;
3269 } 3503 }
3270} 3504}
3271/*}}} */ 3505/*}}} */
3272 3506
3273#ifndef NO_FRILLS 3507#if ENABLE_FRILLS
3274/* ARGSUSED */ 3508/* ARGSUSED */
3275void 3509void
3276rxvt_term::process_window_ops (const int *args, unsigned int nargs) 3510rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3277{ 3511{
3278 int x, y; 3512 int x, y;
3279 XWindowAttributes wattr; 3513 XWindowAttributes wattr;
3280 Window wdummy; 3514 Window wdummy;
3515 dDisp;
3281 3516
3282 if (nargs == 0) 3517 if (nargs == 0)
3283 return; 3518 return;
3284 3519
3285 switch (args[0]) 3520 switch (args[0])
3286 { 3521 {
3287 /* 3522 /*
3288 * commands 3523 * commands
3289 */ 3524 */
3290 case 1: /* deiconify window */ 3525 case 1: /* deiconify window */
3291 XMapWindow (display->display, TermWin.parent[0]); 3526 XMapWindow (disp, parent[0]);
3292 break; 3527 break;
3293 case 2: /* iconify window */ 3528 case 2: /* iconify window */
3294 XIconifyWindow (display->display, TermWin.parent[0], 3529 XIconifyWindow (disp, parent[0], display->screen);
3295 DefaultScreen (display->display));
3296 break; 3530 break;
3297 case 3: /* set position (pixels) */ 3531 case 3: /* set position (pixels) */
3298 XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]); 3532 XMoveWindow (disp, parent[0], args[1], args[2]);
3299 break; 3533 break;
3300 case 4: /* set size (pixels) */ 3534 case 4: /* set size (pixels) */
3301 set_widthheight ((unsigned int)args[2], (unsigned int)args[1]); 3535 set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3302 break; 3536 break;
3303 case 5: /* raise window */ 3537 case 5: /* raise window */
3304 XRaiseWindow (display->display, TermWin.parent[0]); 3538 XRaiseWindow (disp, parent[0]);
3305 break; 3539 break;
3306 case 6: /* lower window */ 3540 case 6: /* lower window */
3307 XLowerWindow (display->display, TermWin.parent[0]); 3541 XLowerWindow (disp, parent[0]);
3308 break; 3542 break;
3309 case 7: /* refresh window */ 3543 case 7: /* refresh window */
3310 scr_touch (true); 3544 scr_touch (true);
3311 break; 3545 break;
3312 case 8: /* set size (chars) */ 3546 case 8: /* set size (chars) */
3313 set_widthheight ((unsigned int) (args[2] * TermWin.fwidth), 3547 set_widthheight ((unsigned int) (args[2] * fwidth),
3314 (unsigned int) (args[1] * TermWin.fheight)); 3548 (unsigned int) (args[1] * fheight));
3315 break; 3549 break;
3316 3550
3317 //case 9: NYI, TODO, restore maximized window or maximize window 3551 //case 9: NYI, TODO, restore maximized window or maximize window
3318 default: 3552 default:
3319 if (args[0] >= 24) /* set height (chars) */ 3553 if (args[0] >= 24) /* set height (chars) */
3320 set_widthheight ((unsigned int)TermWin.width, 3554 set_widthheight ((unsigned int)width,
3321 (unsigned int) (args[1] * TermWin.fheight)); 3555 (unsigned int) (args[1] * fheight));
3322 break; 3556 break;
3323 3557
3324 3558
3325 /* 3559 /*
3326 * reports - some output format copied from XTerm 3560 * reports - some output format copied from XTerm
3327 */ 3561 */
3328 case 11: /* report window state */ 3562 case 11: /* report window state */
3329 XGetWindowAttributes (display->display, TermWin.parent[0], &wattr); 3563 XGetWindowAttributes (disp, parent[0], &wattr);
3330 tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2); 3564 tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3331 break; 3565 break;
3332 case 13: /* report window position */ 3566 case 13: /* report window position */
3333 XGetWindowAttributes (display->display, TermWin.parent[0], &wattr); 3567 XGetWindowAttributes (disp, parent[0], &wattr);
3334 XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root, 3568 XTranslateCoordinates (disp, parent[0], wattr.root,
3335 -wattr.border_width, -wattr.border_width, 3569 -wattr.border_width, -wattr.border_width,
3336 &x, &y, &wdummy); 3570 &x, &y, &wdummy);
3337 tt_printf ("\033[3;%d;%dt", x, y); 3571 tt_printf ("\033[3;%d;%dt", x, y);
3338 break; 3572 break;
3339 case 14: /* report window size (pixels) */ 3573 case 14: /* report window size (pixels) */
3340 XGetWindowAttributes (display->display, TermWin.parent[0], &wattr); 3574 XGetWindowAttributes (disp, parent[0], &wattr);
3341 tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width); 3575 tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3342 break; 3576 break;
3343 case 18: /* report text area size (chars) */ 3577 case 18: /* report text area size (chars) */
3344 tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol); 3578 tt_printf ("\033[8;%d;%dt", nrow, ncol);
3345 break; 3579 break;
3346 case 19: /* report window size (chars) */ 3580 case 19: /* report window size (chars) */
3347 tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol); 3581 tt_printf ("\033[9;%d;%dt", nrow, ncol);
3348 break; 3582 break;
3349 case 20: /* report icon label */ 3583 case 20: /* report icon label */
3350 { 3584 {
3351 char *s; 3585 char *s;
3352 XGetIconName (display->display, TermWin.parent[0], &s); 3586 XGetIconName (disp, parent[0], &s);
3353 tt_printf ("\033]L%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */ 3587 tt_printf ("\033]L%-.250s\234", OPTION (Opt_insecure) && s ? s : ""); /* 8bit ST */
3354 XFree (s); 3588 XFree (s);
3355 } 3589 }
3356 break; 3590 break;
3357 case 21: /* report window title */ 3591 case 21: /* report window title */
3358 { 3592 {
3359 char *s; 3593 char *s;
3360 XFetchName (display->display, TermWin.parent[0], &s); 3594 XFetchName (disp, parent[0], &s);
3361 tt_printf ("\033]l%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */ 3595 tt_printf ("\033]l%-.250s\234", OPTION (Opt_insecure) && s ? s : ""); /* 8bit ST */
3362 XFree (s); 3596 XFree (s);
3363 } 3597 }
3364 break; 3598 break;
3365 } 3599 }
3366} 3600}
… …
3372 * ends_how is terminator used. returned input must be free()'d 3606 * ends_how is terminator used. returned input must be free()'d
3373 */ 3607 */
3374unsigned char * 3608unsigned char *
3375rxvt_term::get_to_st (unicode_t &ends_how) 3609rxvt_term::get_to_st (unicode_t &ends_how)
3376{ 3610{
3377 unicode_t prev = 0, ch; 3611 unicode_t ch;
3612 bool seen_esc = false;
3378 unsigned int n = 0; 3613 unsigned int n = 0;
3379 unsigned char *s;
3380 unsigned char string[STRING_MAX]; 3614 wchar_t string[STRING_MAX];
3381 3615
3382 while ((ch = cmd_getc ()) != NOCHAR) 3616 while ((ch = cmd_getc ()) != NOCHAR)
3383 { 3617 {
3384 if (prev == C0_ESC) 3618 if (seen_esc)
3385 { 3619 {
3386 if (ch == 0x5c) /* 7bit ST */ 3620 if (ch == 0x5c) /* 7bit ST */
3387 break; 3621 break;
3388 else 3622 else
3389 return NULL; 3623 return NULL;
3390 } 3624 }
3625 else if (ch == C0_ESC)
3626 {
3627 seen_esc = true;
3628 continue;
3629 }
3391 else if (ch == C0_BEL || ch == CHAR_ST) 3630 else if (ch == C0_BEL || ch == CHAR_ST)
3392 break; 3631 break;
3393 else if (ch < 0x20) 3632 else if (ch < 0x20)
3394 return NULL; /* other control character - exit */ 3633 return NULL; /* other control character - exit */
3395 3634
3396 if (n >= sizeof (string) - 1) 3635 seen_esc = false;
3636
3637 if (n >= STRING_MAX - 1)
3397 // stop at some sane length 3638 // stop at some sane length
3398 return NULL; 3639 return NULL;
3399 3640
3400 if (ch == C0_SYN) 3641 if (ch == C0_SYN)
3401 {
3402 string[n++] = cmd_get8 (); 3642 string[n++] = cmd_get8 ();
3403 prev = 0;
3404 }
3405 else 3643 else
3406 string[n++] = prev = ch; 3644 string[n++] = ch;
3407 } 3645 }
3408 3646
3409 string[n++] = '\0'; 3647 string[n++] = '\0';
3410 3648
3411 if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3412 return NULL;
3413
3414 ends_how = (ch == 0x5c ? C0_ESC : ch); 3649 ends_how = (ch == 0x5c ? C0_ESC : ch);
3415 STRNCPY (s, string, n); 3650
3416 return s; 3651 return (unsigned char *)rxvt_wcstombs (string);
3417} 3652}
3418 3653
3419/*----------------------------------------------------------------------*/ 3654/*----------------------------------------------------------------------*/
3420/* 3655/*
3421 * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)' 3656 * process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
… …
3466rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp) 3701rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
3467{ 3702{
3468 if (str[0] == '?' && !str[1]) 3703 if (str[0] == '?' && !str[1])
3469 { 3704 {
3470 unsigned short r, g, b; 3705 unsigned short r, g, b;
3471 PixColorsFocused[color].get (display, r, g, b); 3706 pix_colors_focused[color].get (display, r, g, b);
3472 tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp); 3707 tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3473 } 3708 }
3474 else 3709 else
3475 set_window_color (color, str); 3710 set_window_color (color, str);
3476} 3711}
3477 3712
3478/* 3713/*
3479 * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL) 3714 * XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3480 * 0 = change iconName/title
3481 * 1 = change iconName
3482 * 2 = change title
3483 * 4 = change color
3484 * 10 = change fg color
3485 * 11 = change bg color
3486 * 12 = change text color
3487 * 13 = change mouse foreground color
3488 * 17 = change highlight character colour
3489 * 18 = change bold character color
3490 * 19 = change underlined character color
3491 * 46 = change logfile (not implemented)
3492 * 50 = change font
3493 *
3494 * rxvt extensions:
3495 * 20 = bg pixmap
3496 * 39 = change default fg color
3497 * 49 = change default bg color
3498 * 55 = dump scrollback buffer and all of screen
3499 * 701 = change locale
3500 * 702 = find font
3501 * 703 = menu
3502 */ 3715 */
3503void 3716void
3504rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp) 3717rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp)
3505{ 3718{
3506 int changed = 0; 3719 int changed = 0;
3507 int color; 3720 int color;
3508 char *buf, *name; 3721 char *buf, *name;
3509 bool query = str[0] == '?' && !str[1]; 3722 bool query = str[0] == '?' && !str[1];
3723 int saveop = op;
3724 dDisp;
3510 3725
3511 assert (str != NULL); 3726 assert (str != NULL);
3512 switch (op) 3727 switch (op)
3513 { 3728 {
3514 case XTerm_name: 3729 case XTerm_name:
… …
3521 set_title (str); 3736 set_title (str);
3522 break; 3737 break;
3523 case XTerm_property: 3738 case XTerm_property:
3524 if (str[0] == '?') 3739 if (str[0] == '?')
3525 { 3740 {
3526 Atom prop = XInternAtom (display->display, str + 1, True); 3741 Atom prop = display->atom (str + 1);
3527 Atom actual_type; 3742 Atom actual_type;
3528 int actual_format; 3743 int actual_format;
3529 unsigned long nitems; 3744 unsigned long nitems;
3530 unsigned long bytes_after; 3745 unsigned long bytes_after;
3531 unsigned char *value = 0; 3746 unsigned char *value = 0;
3532 const char *str = ""; 3747 const char *str = "";
3533 3748
3534 if (prop 3749 if (prop
3535 && XGetWindowProperty (display->display, TermWin.parent[0], 3750 && XGetWindowProperty (disp, parent[0],
3536 prop, 0, 1<<16, 0, AnyPropertyType, 3751 prop, 0, 1<<16, 0, AnyPropertyType,
3537 &actual_type, &actual_format, 3752 &actual_type, &actual_format,
3538 &nitems, &bytes_after, &value) == Success 3753 &nitems, &bytes_after, &value) == Success
3539 && actual_type != None 3754 && actual_type != None
3540 && actual_format == 8) 3755 && actual_format == 8)
… …
3549 char *eq = strchr (str, '='); // constness lost, but verified to be ok 3764 char *eq = strchr (str, '='); // constness lost, but verified to be ok
3550 3765
3551 if (eq) 3766 if (eq)
3552 { 3767 {
3553 *eq = 0; 3768 *eq = 0;
3554 XChangeProperty (display->display, TermWin.parent[0], 3769 set_utf8_property (display->atom (str), eq + 1);
3555 display->atom (str), XA_STRING, 8,
3556 PropModeReplace, (unsigned char *)eq + 1,
3557 strlen (eq + 1));
3558 } 3770 }
3559 else 3771 else
3560 XDeleteProperty (display->display, TermWin.parent[0], 3772 XDeleteProperty (disp, parent[0],
3561 display->atom (str)); 3773 display->atom (str));
3562 } 3774 }
3563 break; 3775 break;
3564 3776
3565 case XTerm_Color: 3777 case XTerm_Color:
3566 for (buf = (char *)str; buf && *buf;) 3778 for (buf = (char *)str; buf && *buf;)
3567 { 3779 {
3568 if ((name = STRCHR (buf, ';')) == NULL) 3780 if ((name = strchr (buf, ';')) == NULL)
3569 break; 3781 break;
3570 3782
3571 *name++ = '\0'; 3783 *name++ = '\0';
3572 color = atoi (buf); 3784 color = atoi (buf);
3573 3785
3574 if (color < 0 || color >= TOTAL_COLORS) 3786 if (color < 0 || color >= TOTAL_COLORS)
3575 break; 3787 break;
3576 3788
3577 if ((buf = STRCHR (name, ';')) != NULL) 3789 if ((buf = strchr (name, ';')) != NULL)
3578 *buf++ = '\0'; 3790 *buf++ = '\0';
3579 3791
3580 if (name[0] == '?' && !name[1]) 3792 if (name[0] == '?' && !name[1])
3581 { 3793 {
3582 unsigned short r, g, b; 3794 unsigned short r, g, b;
3583 PixColorsFocused[color + minCOLOR].get (display, r, g, b); 3795 pix_colors_focused[color + minCOLOR].get (display, r, g, b);
3584 tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp); 3796 tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3585 } 3797 }
3586 else 3798 else
3587 set_window_color (color + minCOLOR, name); 3799 set_window_color (color + minCOLOR, name);
3588 } 3800 }
… …
3611 case XTerm_Color_UL: 3823 case XTerm_Color_UL:
3612 process_color_seq (XTerm_Color_UL, Color_UL, str, resp); 3824 process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3613 break; 3825 break;
3614 case XTerm_Color_RV: 3826 case XTerm_Color_RV:
3615 process_color_seq (XTerm_Color_RV, Color_RV, str, resp); 3827 process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
3828 break;
3829 case URxvt_Color_IT:
3830 process_color_seq (URxvt_Color_IT, Color_IT, str, resp);
3831 break;
3832#endif
3833#if TRANSPARENT && TINTING
3834 case URxvt_Color_tint:
3835 process_color_seq (URxvt_Color_tint, Color_tint, str, resp);
3836 check_our_parents ();
3837 if (am_transparent)
3838 want_full_refresh = want_refresh = 1;
3616 break; 3839 break;
3617#endif 3840#endif
3618 3841
3619 case XTerm_Pixmap: 3842 case XTerm_Pixmap:
3620 if (*str != ';') 3843 if (*str != ';')
… …
3623 scale_pixmap (""); /* reset to default scaling */ 3846 scale_pixmap (""); /* reset to default scaling */
3624 set_bgPixmap (str); /* change pixmap */ 3847 set_bgPixmap (str); /* change pixmap */
3625#endif 3848#endif
3626 scr_touch (true); 3849 scr_touch (true);
3627 } 3850 }
3628 while ((str = STRCHR (str, ';')) != NULL) 3851 while ((str = strchr (str, ';')) != NULL)
3629 { 3852 {
3630 str++; 3853 str++;
3631#if XPM_BACKGROUND 3854#if XPM_BACKGROUND
3632 changed += scale_pixmap (str); 3855 changed += scale_pixmap (str);
3633#endif 3856#endif
3634
3635 } 3857 }
3858
3636 if (changed) 3859 if (changed)
3637 { 3860 {
3638#ifdef XPM_BACKGROUND 3861#ifdef XPM_BACKGROUND
3639 resize_pixmap (); 3862 resize_pixmap ();
3640#endif 3863#endif
… …
3651 3874
3652 case XTerm_logfile: 3875 case XTerm_logfile:
3653 // TODO, when secure mode? 3876 // TODO, when secure mode?
3654 break; 3877 break;
3655 3878
3656 case XTerm_font:
3657 if (query)
3658 tt_printf ("\33]%d;%-.250s%c", XTerm_font,
3659 (Options & Opt_insecure) && TermWin.fontset->fontdesc
3660 ? TermWin.fontset->fontdesc : "",
3661 resp);
3662 else
3663 change_font (str);
3664 break;
3665
3666#ifndef NO_FRILLS
3667 case XTerm_locale:
3668 if (query)
3669 tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (Options & Opt_insecure) ? locale : "", resp);
3670 else
3671 {
3672 set_locale (str);
3673# ifdef USE_XIM
3674 im_cb ();
3675# endif
3676 }
3677 break;
3678
3679 case XTerm_findfont:
3680 {
3681 int fid = TermWin.fontset->find_font (atoi (str));
3682 tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3683 fid,
3684 (Options & Opt_insecure) ? (*TermWin.fontset)[fid]->name : "",
3685 resp);
3686 }
3687 break;
3688#endif
3689
3690#ifdef MENUBAR 3879#ifdef MENUBAR
3691 case XTerm_Menu: 3880 case URxvt_Menu:
3692 if (Options & Opt_insecure) 3881 if (OPTION (Opt_insecure))
3693 menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked 3882 menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3694 break; 3883 break;
3695#endif 3884#endif
3696#if 0 3885#if 0
3697 case XTerm_dumpscreen: /* no error notices */ 3886 case XTerm_dumpscreen: /* no error notices */
… …
3701 { 3890 {
3702 scr_dump (fd); 3891 scr_dump (fd);
3703 close (fd); 3892 close (fd);
3704 } 3893 }
3705 } 3894 }
3895 break;
3896#endif
3897 case XTerm_font:
3898 op = URxvt_font;
3899 case URxvt_font:
3900#if ENABLE_STYLES
3901 case URxvt_boldFont:
3902 case URxvt_italicFont:
3903 case URxvt_boldItalicFont:
3904#endif
3905 if (query)
3906 tt_printf ("\33]%d;%-.250s%c", saveop,
3907 OPTION (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
3908 ? fontset[op - URxvt_font]->fontdesc : "",
3909 resp);
3910 else
3911 {
3912 const char *&res = rs[Rs_font + (op - URxvt_font)];
3913
3914 res = strdup (str);
3915 allocated.push_back ((void *)res);
3916 set_fonts ();
3917 }
3918 break;
3919
3920#if ENABLE_FRILLS
3921 case URxvt_locale:
3922 if (query)
3923 tt_printf ("\33]%d;%-.250s%c", URxvt_locale, OPTION (Opt_insecure) ? locale : "", resp);
3924 else
3925 {
3926 set_locale (str);
3927 pty.set_utf8_mode (enc_utf8);
3928 init_xlocale ();
3929 }
3930 break;
3931
3932 case URxvt_view_up:
3933 case URxvt_view_down:
3934 int lines = atoi (str);
3935
3936 if (lines)
3937 scr_page (op == URxvt_view_up ? UP : DN, lines);
3938 else
3939 {
3940 scr_erase_savelines ();
3941 }
3942
3706 break; 3943 break;
3707#endif 3944#endif
3708 } 3945 }
3709} 3946}
3710/*----------------------------------------------------------------------*/ 3947/*----------------------------------------------------------------------*/
… …
3724{ 3961{
3725 int state; 3962 int state;
3726 3963
3727 if (mode == 's') 3964 if (mode == 's')
3728 { 3965 {
3729 SavedModes |= (PrivateModes & bit); 3966 SavedModes |= (priv_modes & bit);
3730 return -1; 3967 return -1;
3731 } 3968 }
3732 else 3969 else
3733 { 3970 {
3734 if (mode == 'r') 3971 if (mode == 'r')
3735 state = (SavedModes & bit) ? 1 : 0; /* no overlapping */ 3972 state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3736 else 3973 else
3737 state = (mode == 't') ? ! (PrivateModes & bit) : mode; 3974 state = (mode == 't') ? ! (priv_modes & bit) : mode;
3738 PrivMode (state, bit); 3975 PrivMode (state, bit);
3739 } 3976 }
3740 3977
3741 return state; 3978 return state;
3742} 3979}
… …
3760 { 3, PrivMode_132 }, 3997 { 3, PrivMode_132 },
3761 { 4, PrivMode_smoothScroll }, 3998 { 4, PrivMode_smoothScroll },
3762 { 5, PrivMode_rVideo }, 3999 { 5, PrivMode_rVideo },
3763 { 6, PrivMode_relOrigin }, 4000 { 6, PrivMode_relOrigin },
3764 { 7, PrivMode_Autowrap }, 4001 { 7, PrivMode_Autowrap },
4002 // 8, bi-directional support mode
3765 { 9, PrivMode_MouseX10 }, 4003 { 9, PrivMode_MouseX10 },
3766#ifdef menuBar_esc 4004#ifdef menuBar_esc
3767 { menuBar_esc, PrivMode_menuBar }, 4005 { menuBar_esc, PrivMode_menuBar },
3768#endif 4006#endif
4007 // 18, 19 printing-related
4008 { 25, PrivMode_VisibleCursor },
3769#ifdef scrollBar_esc 4009#ifdef scrollBar_esc
3770 { scrollBar_esc, PrivMode_scrollBar }, 4010 { scrollBar_esc, PrivMode_scrollBar },
3771#endif 4011#endif
3772 // 18, 19 printing-related
3773 { 25, PrivMode_VisibleCursor },
3774 // 30 show scrollbar rxvt. extension
3775 { 35, PrivMode_ShiftKeys }, // rxvt extension 4012 { 35, PrivMode_ShiftKeys }, // rxvt extension
3776 { 40, PrivMode_132OK }, 4013 { 40, PrivMode_132OK },
3777 // 41 xterm more fixes NYI 4014 // 41 xterm more fixes NYI
3778 // 45 margin bell NYI 4015 // 45 margin bell NYI
3779 // 46 start logging 4016 // 46 start logging
… …
3819 } 4056 }
3820 4057
3821 /* extra handling for values with state unkept */ 4058 /* extra handling for values with state unkept */
3822 switch (arg[i]) 4059 switch (arg[i])
3823 { 4060 {
4061#if ENABLE_STYLES
4062 case 1021:
4063 if (mode)
4064 SET_OPTION (Opt_intensityStyles);
4065 else
4066 CLR_OPTION (Opt_intensityStyles);
4067
4068 scr_touch (true);
4069 break;
4070#endif
3824 case 1048: /* alternative cursor save */ 4071 case 1048: /* alternative cursor save */
4072 case 1049:
3825 if (Options & Opt_secondaryScreen) 4073 if (OPTION (Opt_secondaryScreen))
3826 if (mode == 0) 4074 if (mode == 0)
3827 scr_cursor (RESTORE); 4075 scr_cursor (RESTORE);
3828 else if (mode == 1) 4076 else if (mode == 1)
3829 scr_cursor (SAVE); 4077 scr_cursor (SAVE);
3830 break; 4078 break;
… …
3841 * within VT52 mode 4089 * within VT52 mode
3842 */ 4090 */
3843 PrivMode (1, PrivMode_vt52); 4091 PrivMode (1, PrivMode_vt52);
3844 break; 4092 break;
3845 case 3: /* 80/132 */ 4093 case 3: /* 80/132 */
3846 if (PrivateModes & PrivMode_132OK) 4094 if (priv_modes & PrivMode_132OK)
3847 set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height); 4095 set_widthheight (((state ? 132 : 80) * fwidth), height);
3848 break; 4096 break;
3849 case 4: /* smooth scrolling */ 4097 case 4: /* smooth scrolling */
3850 if (state) 4098 if (!state)
3851 Options &= ~Opt_jumpScroll; 4099 SET_OPTION (Opt_jumpScroll);
3852 else 4100 else
3853 Options |= Opt_jumpScroll; 4101 CLR_OPTION (Opt_jumpScroll);
3854 break; 4102 break;
3855 case 5: /* reverse video */ 4103 case 5: /* reverse video */
3856 scr_rvideo_mode (state); 4104 scr_rvideo_mode (state);
3857 break; 4105 break;
3858 case 6: /* relative/absolute origins */ 4106 case 6: /* relative/absolute origins */
… …
3862 scr_autowrap (state); 4110 scr_autowrap (state);
3863 break; 4111 break;
3864 /* case 8: - auto repeat, can't do on a per window basis */ 4112 /* case 8: - auto repeat, can't do on a per window basis */
3865 case 9: /* X10 mouse reporting */ 4113 case 9: /* X10 mouse reporting */
3866 if (state) /* orthogonal */ 4114 if (state) /* orthogonal */
3867 PrivateModes &= ~PrivMode_MouseX11; 4115 priv_modes &= ~PrivMode_MouseX11;
3868 break; 4116 break;
3869#ifdef menuBar_esc 4117#ifdef menuBar_esc
3870 case menuBar_esc: 4118 case menuBar_esc:
3871#ifdef MENUBAR 4119#ifdef MENUBAR
3872 map_menuBar (state); 4120 map_menuBar (state);
… …
3892 break; 4140 break;
3893 /* case 66: - application key pad */ 4141 /* case 66: - application key pad */
3894 /* case 67: - backspace key */ 4142 /* case 67: - backspace key */
3895 case 1000: /* X11 mouse reporting */ 4143 case 1000: /* X11 mouse reporting */
3896 if (state) /* orthogonal */ 4144 if (state) /* orthogonal */
3897 PrivateModes &= ~PrivMode_MouseX10; 4145 priv_modes &= ~PrivMode_MouseX10;
3898 break; 4146 break;
3899#if 0 4147#if 0
3900 case 1001: 4148 case 1001:
3901 break; /* X11 mouse highlighting */ 4149 break; /* X11 mouse highlighting */
3902#endif 4150#endif
3903 case 1010: /* scroll to bottom on TTY output inhibit */ 4151 case 1010: /* scroll to bottom on TTY output inhibit */
3904 if (state) 4152 if (!state)
3905 Options &= ~Opt_scrollTtyOutput; 4153 SET_OPTION (Opt_scrollTtyOutput);
3906 else 4154 else
3907 Options |= Opt_scrollTtyOutput; 4155 CLR_OPTION (Opt_scrollTtyOutput);
3908 break; 4156 break;
3909 case 1011: /* scroll to bottom on key press */ 4157 case 1011: /* scroll to bottom on key press */
3910 if (state) 4158 if (state)
3911 Options |= Opt_scrollTtyKeypress; 4159 SET_OPTION (Opt_scrollTtyKeypress);
3912 else 4160 else
3913 Options &= ~Opt_scrollTtyKeypress; 4161 CLR_OPTION (Opt_scrollTtyKeypress);
3914 break; 4162 break;
3915 case 1047: /* secondary screen w/ clearing last */ 4163 case 1047: /* secondary screen w/ clearing last */
3916 if (Options & Opt_secondaryScreen) 4164 if (OPTION (Opt_secondaryScreen))
3917 if (current_screen != PRIMARY) 4165 if (current_screen != PRIMARY)
3918 scr_erase_screen (2); 4166 scr_erase_screen (2);
3919 scr_change_screen (state); 4167 scr_change_screen (state);
3920 break; 4168 break;
3921 case 1049: /* secondary screen w/ clearing first */ 4169 case 1049: /* secondary screen w/ clearing first */
3922 scr_change_screen (state); 4170 scr_change_screen (state);
3923 if (Options & Opt_secondaryScreen) 4171 if (OPTION (Opt_secondaryScreen))
3924 if (current_screen != PRIMARY) 4172 if (current_screen != PRIMARY)
3925 scr_erase_screen (2); 4173 scr_erase_screen (2);
3926 break; 4174 break;
3927 default: 4175 default:
3928 break; 4176 break;
… …
3954 rendset = 0, rendstyle = ~RS_None; 4202 rendset = 0, rendstyle = ~RS_None;
3955 break; 4203 break;
3956 case 1: 4204 case 1:
3957 rendset = 1, rendstyle = RS_Bold; 4205 rendset = 1, rendstyle = RS_Bold;
3958 break; 4206 break;
3959 //case 2: // faint or second colour 4207 //case 2: // low intensity
4208 case 3:
4209 rendset = 1, rendstyle = RS_Italic;
4210 break;
3960 case 4: 4211 case 4:
3961 rendset = 1, rendstyle = RS_Uline; 4212 rendset = 1, rendstyle = RS_Uline;
3962 break; 4213 break;
3963 case 5: // slowly blinking 4214 case 5: // slowly blinking
3964 case 6: // rapidly blinking 4215 case 6: // rapidly blinking
… …
3976 //case 11: // scoansi acs on, first alt font 4227 //case 11: // scoansi acs on, first alt font
3977 //case 12: // scoansi acs on, |0x80, second alt font 4228 //case 12: // scoansi acs on, |0x80, second alt font
3978 //... 4229 //...
3979 //case 19: // ninth alt font 4230 //case 19: // ninth alt font
3980 //case 20: // gothic 4231 //case 20: // gothic
3981 case 21: // disable bold, faint 4232 case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3982 rendset = 0, rendstyle = RS_Bold; 4233 rendset = 0, rendstyle = RS_Bold;
3983 break; 4234 break;
3984 case 22: 4235 case 22: // normal intensity
3985 rendset = 0, rendstyle = RS_Bold; 4236 rendset = 0, rendstyle = RS_Bold;
3986 break; 4237 break;
3987 //case 23: disable italic 4238 case 23: // disable italic
4239 rendset = 0, rendstyle = RS_Italic;
4240 break;
3988 case 24: 4241 case 24:
3989 rendset = 0, rendstyle = RS_Uline; 4242 rendset = 0, rendstyle = RS_Uline;
3990 break; 4243 break;
3991 case 25: 4244 case 25:
4245 rendset = 0, rendstyle = RS_Blink;
4246 break;
4247 case 26: // variable spacing (iso 8613)
3992 rendset = 0, rendstyle = RS_Blink; 4248 rendset = 0, rendstyle = RS_Blink;
3993 break; 4249 break;
3994 case 27: 4250 case 27:
3995 rendset = 0, rendstyle = RS_RVid; 4251 rendset = 0, rendstyle = RS_RVid;
3996 break; 4252 break;
… …
4014 case 35: 4270 case 35:
4015 case 36: 4271 case 36:
4016 case 37: 4272 case 37:
4017 scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg); 4273 scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
4018 break; 4274 break;
4019#ifdef TTY_256COLOR 4275 case 38: // set fg color, ISO 8613-6
4020 case 38:
4021 if (nargs > i + 2 && arg[i + 1] == 5) 4276 if (nargs > i + 2 && arg[i + 1] == 5)
4022 { 4277 {
4023 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg); 4278 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
4024 i += 2; 4279 i += 2;
4025 } 4280 }
4026 break; 4281 break;
4027#endif
4028 case 39: /* default fg */ 4282 case 39: /* default fg */
4029 scr_color (Color_fg, Color_fg); 4283 scr_color (Color_fg, Color_fg);
4030 break; 4284 break;
4031 4285
4032 case 40: 4286 case 40:
… …
4037 case 45: 4291 case 45:
4038 case 46: 4292 case 46:
4039 case 47: 4293 case 47:
4040 scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg); 4294 scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
4041 break; 4295 break;
4042#ifdef TTY_256COLOR 4296 case 48: // set bg color, ISO 8613-6
4043 case 48:
4044 if (nargs > i + 2 && arg[i + 1] == 5) 4297 if (nargs > i + 2 && arg[i + 1] == 5)
4045 { 4298 {
4046 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg); 4299 scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
4047 i += 2; 4300 i += 2;
4048 } 4301 }
4049 break; 4302 break;
4050#endif
4051 case 49: /* default bg */ 4303 case 49: /* default bg */
4052 scr_color (Color_bg, Color_bg); 4304 scr_color (Color_bg, Color_bg);
4053 break; 4305 break;
4306
4307 //case 50: // not variable spacing
4054 4308
4055#ifndef NO_BRIGHTCOLOR 4309#ifndef NO_BRIGHTCOLOR
4056 case 90: 4310 case 90:
4057 case 91: /* set bright fg color */ 4311 case 91: /* set bright fg color */
4058 case 92: 4312 case 92:
4059 case 93: 4313 case 93:
4060 case 94: 4314 case 94:
4061 case 95: 4315 case 95:
4062 case 96: 4316 case 96:
4063 case 97: 4317 case 97:
4064 scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), 4318 scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
4065 Color_fg);
4066 break; 4319 break;
4067 case 100: 4320 case 100:
4068 case 101: /* set bright bg color */ 4321 case 101: /* set bright bg color */
4069 case 102: 4322 case 102:
4070 case 103: 4323 case 103:
4071 case 104: 4324 case 104:
4072 case 105: 4325 case 105:
4073 case 106: 4326 case 106:
4074 case 107: 4327 case 107:
4075 scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), 4328 scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
4076 Color_bg);
4077 break; 4329 break;
4078#endif 4330#endif
4079
4080 } 4331 }
4081 } 4332 }
4082} 4333}
4083/*}}} */ 4334/*}}} */
4084 4335
… …
4088{ 4339{
4089 unicode_t ch, cmd = cmd_getc (); 4340 unicode_t ch, cmd = cmd_getc ();
4090 4341
4091 if (cmd == 'Q') 4342 if (cmd == 'Q')
4092 { /* query graphics */ 4343 { /* query graphics */
4093 tt_printf ("\033G0\n"); /* no graphics */ 4344 tt_printf ("\033G0\012"); /* no graphics */
4094 return; 4345 return;
4095 } 4346 }
4096 /* swallow other graphics sequences until terminating ':' */ 4347 /* swallow other graphics sequences until terminating ':' */
4097 do 4348 do
4098 ch = cmd_getc (); 4349 ch = cmd_getc ();
… …
4113 unsigned char buf[256]; 4364 unsigned char buf[256];
4114 4365
4115 va_start (arg_ptr, fmt); 4366 va_start (arg_ptr, fmt);
4116 vsnprintf ((char *)buf, 256, fmt, arg_ptr); 4367 vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4117 va_end (arg_ptr); 4368 va_end (arg_ptr);
4118 tt_write (buf, STRLEN (buf)); 4369 tt_write (buf, strlen (buf));
4119} 4370}
4120 4371
4121/* ---------------------------------------------------------------------- */ 4372/* ---------------------------------------------------------------------- */
4122/* Write data to the pty as typed by the user, pasted with the mouse, 4373/* Write data to the pty as typed by the user, pasted with the mouse,
4123 * or generated by us in response to a query ESC sequence. 4374 * or generated by us in response to a query ESC sequence.
4124 */ 4375 */
4376const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
4377
4125void 4378void
4126rxvt_term::tt_write (const unsigned char *data, unsigned int len) 4379rxvt_term::tt_write (const unsigned char *data, unsigned int len)
4127{ 4380{
4128 enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT 4381 if (v_buflen == 0)
4382 {
4383 ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
4129 4384
4130 if (len) 4385 if ((unsigned int)written == len)
4386 return;
4387
4388 data += written;
4389 len -= written;
4131 { 4390 }
4391
4392 v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
4393
4394 memcpy (v_buffer + v_buflen, data, len);
4395 v_buflen += len;
4396
4397 pty_ev.set (EVENT_READ | EVENT_WRITE);
4398}
4399
4400void rxvt_term::pty_write ()
4401{
4402 int written = write (pty.pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
4403
4404 if (written > 0)
4405 {
4406 v_buflen -= written;
4407
4132 if (v_buflen == 0) 4408 if (v_buflen == 0)
4133 { 4409 {
4134 ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));
4135
4136 if ((unsigned int)written == len)
4137 return;
4138
4139 data += written;
4140 len -= written;
4141 }
4142
4143
4144 v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
4145
4146 memcpy (v_buffer + v_buflen, data, len);
4147 v_buflen += len;
4148 }
4149
4150 for (;;)
4151 {
4152 int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));
4153
4154 if (written > 0)
4155 {
4156 v_buflen -= written;
4157
4158 if (v_buflen == 0)
4159 {
4160 free (v_buffer); 4410 free (v_buffer);
4161 v_buffer = 0; 4411 v_buffer = 0;
4162 v_buflen = 0; 4412 v_buflen = 0;
4163 4413
4164 pty_ev.set (EVENT_READ); 4414 pty_ev.set (EVENT_READ);
4165 return;
4166 }
4167
4168 memmove (v_buffer, v_buffer + written, v_buflen);
4169 }
4170 else if (written != -1 || (errno != EAGAIN && errno != EINTR))
4171 // original code just ignores this...
4172 destroy ();
4173 else
4174 {
4175 pty_ev.set (EVENT_READ | EVENT_WRITE);
4176 return; 4415 return;
4177 } 4416 }
4417
4418 memmove (v_buffer, v_buffer + written, v_buflen);
4178 } 4419 }
4420 else if (written != -1 || (errno != EAGAIN && errno != EINTR))
4421 pty_ev.set (EVENT_READ);
4179} 4422}
4180 4423
4181/*----------------------- end-of-file (C source) -----------------------*/ 4424/*----------------------- end-of-file (C source) -----------------------*/
4182 4425

Diff Legend

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