?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add support for mouse tracking.
[screen-lua.git] / src / process.c
blob8136fd5ba260de3bbc0009282ee10d2fc70863fa
1 /* Copyright (c) 2008, 2009
2 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
3 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
4 * Micah Cowan (micah@cowan.name)
5 * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
6 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
7 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
8 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
9 * Copyright (c) 1987 Oliver Laumann
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 3, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program (see the file COPYING); if not, see
23 * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
25 *
26 ****************************************************************
27 */
28
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <signal.h>
32 #include <fcntl.h>
33 #if !defined(sun) && !defined(B43) && !defined(ISC) && !defined(pyr) && !defined(_CX_UX)
34 # include <time.h>
35 #endif
36 #include <sys/time.h>
37 #ifndef sun
38 #include <sys/ioctl.h>
39 #endif
40
41
42 #include "config.h"
43
44 /* for solaris 2.1, Unixware (SVR4.2) and possibly others: */
45 #ifdef HAVE_STROPTS_H
46 # include <sys/stropts.h>
47 #endif
48
49 #include "screen.h"
50 #include "extern.h"
51 #include "logfile.h"
52
53 extern struct comm comms[];
54 extern char *rc_name;
55 extern char *RcFileName, *home;
56 extern char *BellString, *ActivityString, *ShellProg, *ShellArgs[];
57 extern char *hstatusstring, *captionstring, *timestring;
58 extern char *wliststr, *wlisttit;
59 extern int captionalways;
60 extern char *hardcopydir, *screenlogfile, *logtstamp_string;
61 extern int log_flush, logtstamp_on, logtstamp_after;
62 extern char *VisualBellString;
63 extern int VBellWait, MsgWait, MsgMinWait, SilenceWait;
64 extern char SockPath[], *SockName;
65 extern int TtyMode, auto_detach, use_altscreen;
66 extern int iflag, maxwin;
67 extern int focusminwidth, focusminheight;
68 extern int use_hardstatus, visual_bell;
69 #ifdef COLOR
70 extern int attr2color[][4];
71 extern int nattr2color;
72 #endif
73 extern int hardstatusemu;
74 extern char *printcmd;
75 extern int default_startup;
76 extern int defobuflimit;
77 extern int defnonblock;
78 extern int defmousetrack;
79 extern int ZombieKey_destroy;
80 extern int ZombieKey_resurrect;
81 extern int ZombieKey_onerror;
82 #ifdef AUTO_NUKE
83 extern int defautonuke;
84 #endif
85 extern int separate_sids;
86 extern struct NewWindow nwin_default, nwin_undef;
87 #ifdef COPY_PASTE
88 extern int join_with_cr;
89 extern int compacthist;
90 extern int search_ic;
91 # ifdef FONT
92 extern int pastefont;
93 # endif
94 extern unsigned char mark_key_tab[];
95 extern char *BufferFile;
96 #endif
97 #ifdef POW_DETACH
98 extern char *BufferFile, *PowDetachString;
99 #endif
100 #ifdef MULTIUSER
101 extern struct acluser *EffectiveAclUser; /* acl.c */
102 #endif
103 extern struct term term[]; /* terminal capabilities */
104 #ifdef MAPKEYS
105 extern char *kmapdef[];
106 extern char *kmapadef[];
107 extern char *kmapmdef[];
108 #endif
109 extern struct mchar mchar_so, mchar_null;
110 extern int renditions[];
111 extern int VerboseCreate;
112 #ifdef UTF8
113 extern char *screenencodings;
114 #endif
115 #ifdef DW_CHARS
116 extern int cjkwidth;
117 #endif
118
119 static int CheckArgNum __P((int, char **));
120 static void ClearAction __P((struct action *));
121 static void SaveAction __P((struct action *, int, char **, int *));
122 static int NextWindow __P((void));
123 static int PreviousWindow __P((void));
124 static int MoreWindows __P((void));
125 static void LogToggle __P((int));
126 static void ShowInfo __P((void));
127 static void ShowDInfo __P((void));
128 static struct win *WindowByName __P((char *));
129 static int WindowByNumber __P((char *));
130 static int ParseOnOff __P((struct action *, int *));
131 static int ParseWinNum __P((struct action *, int *));
132 static int ParseBase __P((struct action *, char *, int *, int, char *));
133 static int ParseNum1000 __P((struct action *, int *));
134 static char **SaveArgs __P((char **));
135 static int IsNum __P((char *, int));
136 static void Colonfin __P((char *, int, char *));
137 static void InputSelect __P((void));
138 static void InputSetenv __P((char *));
139 static void InputAKA __P((void));
140 #ifdef MULTIUSER
141 static int InputSu __P((struct win *, struct acluser **, char *));
142 static void su_fin __P((char *, int, char *));
143 #endif
144 static void AKAfin __P((char *, int, char *));
145 #ifdef COPY_PASTE
146 static void copy_reg_fn __P((char *, int, char *));
147 static void ins_reg_fn __P((char *, int, char *));
148 #endif
149 static void process_fn __P((char *, int, char *));
150 #ifdef PASSWORD
151 static void pass1 __P((char *, int, char *));
152 static void pass2 __P((char *, int, char *));
153 #endif
154 #ifdef POW_DETACH
155 static void pow_detach_fn __P((char *, int, char *));
156 #endif
157 static void digraph_fn __P((char *, int, char *));
158 static int digraph_find __P((const char *buf));
159 static void confirm_fn __P((char *, int, char *));
160 static int IsOnDisplay __P((struct win *));
161 static void ResizeRegions __P((char *, int));
162 static void ResizeFin __P((char *, int, char *));
163 static struct action *FindKtab __P((char *, int));
164 static void SelectFin __P((char *, int, char *));
165 static void SelectLayoutFin __P((char *, int, char *));
166
167
168 extern struct layer *flayer;
169 extern struct display *display, *displays;
170 extern struct win *fore, *console_window, *windows;
171 extern struct acluser *users;
172 extern struct layout *layouts, *layout_attach, layout_last_marker;
173 extern struct layout *laytab[];
174
175 extern char screenterm[], HostName[], version[];
176 extern struct NewWindow nwin_undef, nwin_default;
177 extern struct LayFuncs WinLf, MarkLf;
178
179 extern int Z0width, Z1width;
180 extern int real_uid, real_gid;
181
182 #ifdef NETHACK
183 extern int nethackflag;
184 #endif
185
186
187 struct win *wtab[MAXWIN]; /* window table, should be dynamic */
188
189 #ifdef MULTIUSER
190 extern char *multi;
191 extern int maxusercount;
192 #endif
193 char NullStr[] = "";
194
195 struct plop plop_tab[MAX_PLOP_DEFS];
196
197 #ifndef PTYMODE
198 # define PTYMODE 0622
199 #endif
200
201 int TtyMode = PTYMODE;
202 int hardcopy_append = 0;
203 int all_norefresh = 0;
204 #ifdef ZMODEM
205 int zmodem_mode = 0;
206 char *zmodem_sendcmd;
207 char *zmodem_recvcmd;
208 static char *zmodes[4] = {"off", "auto", "catch", "pass"};
209 #endif
210
211 int idletimo;
212 struct action idleaction;
213 #ifdef BLANKER_PRG
214 char **blankerprg;
215 #endif
216
217 struct action ktab[256 + KMAP_KEYS]; /* command key translation table */
218 struct kclass {
219 struct kclass *next;
220 char *name;
221 struct action ktab[256 + KMAP_KEYS];
222 };
223 struct kclass *kclasses;
224
225 #ifdef MAPKEYS
226 struct action umtab[KMAP_KEYS+KMAP_AKEYS];
227 struct action dmtab[KMAP_KEYS+KMAP_AKEYS];
228 struct action mmtab[KMAP_KEYS+KMAP_AKEYS];
229 struct kmap_ext *kmap_exts;
230 int kmap_extn;
231 static int maptimeout = 300;
232 #endif
233
234 #ifndef MAX_DIGRAPH
235 #define MAX_DIGRAPH 512
236 #endif
237
238 struct digraph
239 {
240 unsigned char d[2];
241 int value;
242 };
243
244 /* digraph table taken from old vim and rfc1345 */
245 static struct digraph digraphs[MAX_DIGRAPH + 1] = {
246 {' ', ' ', 160}, /*   */
247 {'N', 'S', 160}, /*   */
248 {'~', '!', 161}, /* ¡ */
249 {'!', '!', 161}, /* ¡ */
250 {'!', 'I', 161}, /* ¡ */
251 {'c', '|', 162}, /* ¢ */
252 {'c', 't', 162}, /* ¢ */
253 {'$', '$', 163}, /* £ */
254 {'P', 'd', 163}, /* £ */
255 {'o', 'x', 164}, /* ¤ */
256 {'C', 'u', 164}, /* ¤ */
257 {'C', 'u', 164}, /* ¤ */
258 {'E', 'u', 164}, /* ¤ */
259 {'Y', '-', 165}, /* ¥ */
260 {'Y', 'e', 165}, /* ¥ */
261 {'|', '|', 166}, /* ¦ */
262 {'B', 'B', 166}, /* ¦ */
263 {'p', 'a', 167}, /* § */
264 {'S', 'E', 167}, /* § */
265 {'"', '"', 168}, /* ¨ */
266 {'\'', ':', 168}, /* ¨ */
267 {'c', 'O', 169}, /* © */
268 {'C', 'o', 169}, /* © */
269 {'a', '-', 170}, /* ª */
270 {'<', '<', 171}, /* « */
271 {'-', ',', 172}, /* ¬ */
272 {'N', 'O', 172}, /* ¬ */
273 {'-', '-', 173}, /* ­ */
274 {'r', 'O', 174}, /* ® */
275 {'R', 'g', 174}, /* ® */
276 {'-', '=', 175}, /* ¯ */
277 {'\'', 'm', 175}, /* ¯ */
278 {'~', 'o', 176}, /* ° */
279 {'D', 'G', 176}, /* ° */
280 {'+', '-', 177}, /* ± */
281 {'2', '2', 178}, /* ² */
282 {'2', 'S', 178}, /* ² */
283 {'3', '3', 179}, /* ³ */
284 {'3', 'S', 179}, /* ³ */
285 {'\'', '\'', 180}, /* ´ */
286 {'j', 'u', 181}, /* µ */
287 {'M', 'y', 181}, /* µ */
288 {'p', 'p', 182}, /* ¶ */
289 {'P', 'I', 182}, /* ¶ */
290 {'~', '.', 183}, /* · */
291 {'.', 'M', 183}, /* · */
292 {',', ',', 184}, /* ¸ */
293 {'\'', ',', 184}, /* ¸ */
294 {'1', '1', 185}, /* ¹ */
295 {'1', 'S', 185}, /* ¹ */
296 {'o', '-', 186}, /* º */
297 {'>', '>', 187}, /* » */
298 {'1', '4', 188}, /* ¼ */
299 {'1', '2', 189}, /* ½ */
300 {'3', '4', 190}, /* ¾ */
301 {'~', '?', 191}, /* ¿ */
302 {'?', '?', 191}, /* ¿ */
303 {'?', 'I', 191}, /* ¿ */
304 {'A', '`', 192}, /* À */
305 {'A', '!', 192}, /* À */
306 {'A', '\'', 193}, /* Á */
307 {'A', '^', 194}, /* Â */
308 {'A', '>', 194}, /* Â */
309 {'A', '~', 195}, /* Ã */
310 {'A', '?', 195}, /* Ã */
311 {'A', '"', 196}, /* Ä */
312 {'A', ':', 196}, /* Ä */
313 {'A', '@', 197}, /* Å */
314 {'A', 'A', 197}, /* Å */
315 {'A', 'E', 198}, /* Æ */
316 {'C', ',', 199}, /* Ç */
317 {'E', '`', 200}, /* È */
318 {'E', '!', 200}, /* È */
319 {'E', '\'', 201}, /* É */
320 {'E', '^', 202}, /* Ê */
321 {'E', '>', 202}, /* Ê */
322 {'E', '"', 203}, /* Ë */
323 {'E', ':', 203}, /* Ë */
324 {'I', '`', 204}, /* Ì */
325 {'I', '!', 204}, /* Ì */
326 {'I', '\'', 205}, /* Í */
327 {'I', '^', 206}, /* Î */
328 {'I', '>', 206}, /* Î */
329 {'I', '"', 207}, /* Ï */
330 {'I', ':', 207}, /* Ï */
331 {'D', '-', 208}, /* Ð */
332 {'N', '~', 209}, /* Ñ */
333 {'N', '?', 209}, /* Ñ */
334 {'O', '`', 210}, /* Ò */
335 {'O', '!', 210}, /* Ò */
336 {'O', '\'', 211}, /* Ó */
337 {'O', '^', 212}, /* Ô */
338 {'O', '>', 212}, /* Ô */
339 {'O', '~', 213}, /* Õ */
340 {'O', '?', 213}, /* Õ */
341 {'O', '"', 214}, /* Ö */
342 {'O', ':', 214}, /* Ö */
343 {'/', '\\', 215}, /* × */
344 {'*', 'x', 215}, /* × */
345 {'O', '/', 216}, /* Ø */
346 {'U', '`', 217}, /* Ù */
347 {'U', '!', 217}, /* Ù */
348 {'U', '\'', 218}, /* Ú */
349 {'U', '^', 219}, /* Û */
350 {'U', '>', 219}, /* Û */
351 {'U', '"', 220}, /* Ü */
352 {'U', ':', 220}, /* Ü */
353 {'Y', '\'', 221}, /* Ý */
354 {'I', 'p', 222}, /* Þ */
355 {'T', 'H', 222}, /* Þ */
356 {'s', 's', 223}, /* ß */
357 {'s', '"', 223}, /* ß */
358 {'a', '`', 224}, /* à */
359 {'a', '!', 224}, /* à */
360 {'a', '\'', 225}, /* á */
361 {'a', '^', 226}, /* â */
362 {'a', '>', 226}, /* â */
363 {'a', '~', 227}, /* ã */
364 {'a', '?', 227}, /* ã */
365 {'a', '"', 228}, /* ä */
366 {'a', ':', 228}, /* ä */
367 {'a', 'a', 229}, /* å */
368 {'a', 'e', 230}, /* æ */
369 {'c', ',', 231}, /* ç */
370 {'e', '`', 232}, /* è */
371 {'e', '!', 232}, /* è */
372 {'e', '\'', 233}, /* é */
373 {'e', '^', 234}, /* ê */
374 {'e', '>', 234}, /* ê */
375 {'e', '"', 235}, /* ë */
376 {'e', ':', 235}, /* ë */
377 {'i', '`', 236}, /* ì */
378 {'i', '!', 236}, /* ì */
379 {'i', '\'', 237}, /* í */
380 {'i', '^', 238}, /* î */
381 {'i', '>', 238}, /* î */
382 {'i', '"', 239}, /* ï */
383 {'i', ':', 239}, /* ï */
384 {'d', '-', 240}, /* ð */
385 {'n', '~', 241}, /* ñ */
386 {'n', '?', 241}, /* ñ */
387 {'o', '`', 242}, /* ò */
388 {'o', '!', 242}, /* ò */
389 {'o', '\'', 243}, /* ó */
390 {'o', '^', 244}, /* ô */
391 {'o', '>', 244}, /* ô */
392 {'o', '~', 245}, /* õ */
393 {'o', '?', 245}, /* õ */
394 {'o', '"', 246}, /* ö */
395 {'o', ':', 246}, /* ö */
396 {':', '-', 247}, /* ÷ */
397 {'o', '/', 248}, /* ø */
398 {'u', '`', 249}, /* ù */
399 {'u', '!', 249}, /* ù */
400 {'u', '\'', 250}, /* ú */
401 {'u', '^', 251}, /* û */
402 {'u', '>', 251}, /* û */
403 {'u', '"', 252}, /* ü */
404 {'u', ':', 252}, /* ü */
405 {'y', '\'', 253}, /* ý */
406 {'i', 'p', 254}, /* þ */
407 {'t', 'h', 254}, /* þ */
408 {'y', '"', 255}, /* ÿ */
409 {'y', ':', 255}, /* ÿ */
410 {'"', '[', 196}, /* Ä */
411 {'"', '\\', 214}, /* Ö */
412 {'"', ']', 220}, /* Ü */
413 {'"', '{', 228}, /* ä */
414 {'"', '|', 246}, /* ö */
415 {'"', '}', 252}, /* ü */
416 {'"', '~', 223} /* ß */
417 };
418
419 #define RESIZE_FLAG_H 1
420 #define RESIZE_FLAG_V 2
421 #define RESIZE_FLAG_L 4
422
423 static char *resizeprompts[] = {
424 "resize # lines: ",
425 "resize -h # lines: ",
426 "resize -v # lines: ",
427 "resize -b # lines: ",
428 "resize -l # lines: ",
429 "resize -l -h # lines: ",
430 "resize -l -v # lines: ",
431 "resize -l -b # lines: ",
432 };
433
434 static int
435 parse_input_int(buf, len, val)
436 const char *buf;
437 int len;
438 int *val;
439 {
440 int x = 0, i;
441 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
442 {
443 x = 0;
444 for (i = 2; i < len; i++)
445 {
446 if (buf[i] >= '0' && buf[i] <= '9')
447 x = x * 16 | (buf[i] - '0');
448 else if (buf[i] >= 'a' && buf[i] <= 'f')
449 x = x * 16 | (buf[i] - ('a' - 10));
450 else if (buf[i] >= 'A' && buf[i] <= 'F')
451 x = x * 16 | (buf[i] - ('A' - 10));
452 else
453 return 0;
454 }
455 }
456 else if (buf[0] == '0')
457 {
458 x = 0;
459 for (i = 1; i < len; i++)
460 {
461 if (buf[i] < '0' || buf[i] > '7')
462 return 0;
463 x = x * 8 | (buf[i] - '0');
464 }
465 }
466 else
467 return 0;
468 *val = x;
469 return 1;
470 }
471
472 char *noargs[1];
473
474 void
475 InitKeytab()
476 {
477 register unsigned int i;
478 #ifdef MAPKEYS
479 char *argarr[2];
480 #endif
481
482 for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++)
483 {
484 ktab[i].nr = RC_ILLEGAL;
485 ktab[i].args = noargs;
486 ktab[i].argl = 0;
487 }
488 #ifdef MAPKEYS
489 for (i = 0; i < KMAP_KEYS+KMAP_AKEYS; i++)
490 {
491 umtab[i].nr = RC_ILLEGAL;
492 umtab[i].args = noargs;
493 umtab[i].argl = 0;
494 dmtab[i].nr = RC_ILLEGAL;
495 dmtab[i].args = noargs;
496 dmtab[i].argl = 0;
497 mmtab[i].nr = RC_ILLEGAL;
498 mmtab[i].args = noargs;
499 mmtab[i].argl = 0;
500 }
501 argarr[1] = 0;
502 for (i = 0; i < NKMAPDEF; i++)
503 {
504 if (i + KMAPDEFSTART < T_CAPS)
505 continue;
506 if (i + KMAPDEFSTART >= T_CAPS + KMAP_KEYS)
507 continue;
508 if (kmapdef[i] == 0)
509 continue;
510 argarr[0] = kmapdef[i];
511 SaveAction(dmtab + i + (KMAPDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
512 }
513 for (i = 0; i < NKMAPADEF; i++)
514 {
515 if (i + KMAPADEFSTART < T_CURSOR)
516 continue;
517 if (i + KMAPADEFSTART >= T_CURSOR + KMAP_AKEYS)
518 continue;
519 if (kmapadef[i] == 0)
520 continue;
521 argarr[0] = kmapadef[i];
522 SaveAction(dmtab + i + (KMAPADEFSTART - T_CURSOR + KMAP_KEYS), RC_STUFF, argarr, 0);
523 }
524 for (i = 0; i < NKMAPMDEF; i++)
525 {
526 if (i + KMAPMDEFSTART < T_CAPS)
527 continue;
528 if (i + KMAPMDEFSTART >= T_CAPS + KMAP_KEYS)
529 continue;
530 if (kmapmdef[i] == 0)
531 continue;
532 argarr[0] = kmapmdef[i];
533 argarr[1] = 0;
534 SaveAction(mmtab + i + (KMAPMDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
535 }
536 #endif
537
538 ktab['h'].nr = RC_HARDCOPY;
539 #ifdef BSDJOBS
540 ktab['z'].nr = ktab[Ctrl('z')].nr = RC_SUSPEND;
541 #endif
542 ktab['c'].nr = ktab[Ctrl('c')].nr = RC_SCREEN;
543 ktab[' '].nr = ktab[Ctrl(' ')].nr =
544 ktab['n'].nr = ktab[Ctrl('n')].nr = RC_NEXT;
545 ktab['N'].nr = RC_NUMBER;
546 ktab[Ctrl('h')].nr = ktab[0177].nr = ktab['p'].nr = ktab[Ctrl('p')].nr = RC_PREV;
547 ktab['k'].nr = ktab[Ctrl('k')].nr = RC_KILL;
548 ktab['l'].nr = ktab[Ctrl('l')].nr = RC_REDISPLAY;
549 ktab['w'].nr = ktab[Ctrl('w')].nr = RC_WINDOWS;
550 ktab['v'].nr = RC_VERSION;
551 ktab[Ctrl('v')].nr = RC_DIGRAPH;
552 ktab['q'].nr = ktab[Ctrl('q')].nr = RC_XON;
553 ktab['s'].nr = ktab[Ctrl('s')].nr = RC_XOFF;
554 ktab['t'].nr = ktab[Ctrl('t')].nr = RC_TIME;
555 ktab['i'].nr = ktab[Ctrl('i')].nr = RC_INFO;
556 ktab['m'].nr = ktab[Ctrl('m')].nr = RC_LASTMSG;
557 ktab['A'].nr = RC_TITLE;
558 #if defined(UTMPOK) && defined(LOGOUTOK)
559 ktab['L'].nr = RC_LOGIN;
560 #endif
561 ktab[','].nr = RC_LICENSE;
562 ktab['W'].nr = RC_WIDTH;
563 ktab['.'].nr = RC_DUMPTERMCAP;
564 ktab[Ctrl('\\')].nr = RC_QUIT;
565 #ifdef DETACH
566 ktab['d'].nr = ktab[Ctrl('d')].nr = RC_DETACH;
567 # ifdef POW_DETACH
568 ktab['D'].nr = RC_POW_DETACH;
569 # endif
570 #endif
571 ktab['r'].nr = ktab[Ctrl('r')].nr = RC_WRAP;
572 ktab['f'].nr = ktab[Ctrl('f')].nr = RC_FLOW;
573 ktab['C'].nr = RC_CLEAR;
574 ktab['Z'].nr = RC_RESET;
575 ktab['H'].nr = RC_LOG;
576 ktab['M'].nr = RC_MONITOR;
577 ktab['?'].nr = RC_HELP;
578 #ifdef MULTI
579 ktab['*'].nr = RC_DISPLAYS;
580 #endif
581 {
582 char *args[2];
583 args[0] = "-";
584 args[1] = NULL;
585 SaveAction(ktab + '-', RC_SELECT, args, 0);
586 }
587 for (i = 0; i < ((MAXWIN < 10) ? MAXWIN : 10); i++)
588 {
589 char *args[2], arg1[10];
590 args[0] = arg1;
591 args[1] = 0;
592 sprintf(arg1, "%d", i);
593 SaveAction(ktab + '0' + i, RC_SELECT, args, 0);
594 }
595 ktab['\''].nr = RC_SELECT; /* calling a window by name */
596 {
597 char *args[2];
598 args[0] = "-b";
599 args[1] = 0;
600 SaveAction(ktab + '"', RC_WINDOWLIST, args, 0);
601 }
602 ktab[Ctrl('G')].nr = RC_VBELL;
603 ktab[':'].nr = RC_COLON;
604 #ifdef COPY_PASTE
605 ktab['['].nr = ktab[Ctrl('[')].nr = RC_COPY;
606 {
607 char *args[2];
608 args[0] = ".";
609 args[1] = 0;
610 SaveAction(ktab + ']', RC_PASTE, args, 0);
611 SaveAction(ktab + Ctrl(']'), RC_PASTE, args, 0);
612 }
613 ktab['{'].nr = RC_HISTORY;
614 ktab['}'].nr = RC_HISTORY;
615 ktab['>'].nr = RC_WRITEBUF;
616 ktab['<'].nr = RC_READBUF;
617 ktab['='].nr = RC_REMOVEBUF;
618 #endif
619 #ifdef POW_DETACH
620 ktab['D'].nr = RC_POW_DETACH;
621 #endif
622 #ifdef LOCK
623 ktab['x'].nr = ktab[Ctrl('x')].nr = RC_LOCKSCREEN;
624 #endif
625 ktab['b'].nr = ktab[Ctrl('b')].nr = RC_BREAK;
626 ktab['B'].nr = RC_POW_BREAK;
627 ktab['_'].nr = RC_SILENCE;
628 ktab['S'].nr = RC_SPLIT;
629 ktab['Q'].nr = RC_ONLY;
630 ktab['X'].nr = RC_REMOVE;
631 ktab['F'].nr = RC_FIT;
632 ktab['\t'].nr = RC_FOCUS;
633 {
634 char *args[2];
635 args[0] = "prev";
636 args[1] = 0;
637 SaveAction(ktab + T_BACKTAB - T_CAPS + 256, RC_FOCUS, args, 0);
638 }
639 {
640 char *args[2];
641 args[0] = "-v";
642 args[1] = 0;
643 SaveAction(ktab + '|', RC_SPLIT, args, 0);
644 }
645 /* These come last; they may want overwrite others: */
646 if (DefaultEsc >= 0)
647 {
648 ClearAction(&ktab[DefaultEsc]);
649 ktab[DefaultEsc].nr = RC_OTHER;
650 }
651 if (DefaultMetaEsc >= 0)
652 {
653 ClearAction(&ktab[DefaultMetaEsc]);
654 ktab[DefaultMetaEsc].nr = RC_META;
655 }
656
657 idleaction.nr = RC_BLANKER;
658 idleaction.args = noargs;
659 idleaction.argl = 0;
660 }
661
662 static struct action *
663 FindKtab(class, create)
664 char *class;
665 int create;
666 {
667 struct kclass *kp, **kpp;
668 int i;
669
670 if (class == 0)
671 return ktab;
672 for (kpp = &kclasses; (kp = *kpp) != 0; kpp = &kp->next)
673 if (!strcmp(kp->name, class))
674 break;
675 if (kp == 0)
676 {
677 if (!create)
678 return 0;
679 if (strlen(class) > 80)
680 {
681 Msg(0, "Command class name too long.");
682 return 0;
683 }
684 kp = malloc(sizeof(*kp));
685 if (kp == 0)
686 {
687 Msg(0, strnomem);
688 return 0;
689 }
690 kp->name = SaveStr(class);
691 for (i = 0; i < (int)(sizeof(kp->ktab)/sizeof(*kp->ktab)); i++)
692 {
693 kp->ktab[i].nr = RC_ILLEGAL;
694 kp->ktab[i].args = noargs;
695 kp->ktab[i].argl = 0;
696 }
697 kp->next = 0;
698 *kpp = kp;
699 }
700 return kp->ktab;
701 }
702
703 static void
704 ClearAction(act)
705 struct action *act;
706 {
707 char **p;
708
709 if (act->nr == RC_ILLEGAL)
710 return;
711 act->nr = RC_ILLEGAL;
712 if (act->args == noargs)
713 return;
714 for (p = act->args; *p; p++)
715 free(*p);
716 free((char *)act->args);
717 act->args = noargs;
718 act->argl = 0;
719 }
720
721 /*
722 * ProcessInput: process input from display and feed it into
723 * the layer on canvas D_forecv.
724 */
725
726 #ifdef MAPKEYS
727
728 /*
729 * This ProcessInput just does the keybindings and passes
730 * everything else on to ProcessInput2.
731 */
732
733 void
734 ProcessInput(ibuf, ilen)
735 char *ibuf;
736 int ilen;
737 {
738 int ch, slen;
739 unsigned char *s, *q;
740 int i, l;
741 char *p;
742
743 debug1("ProcessInput: %d bytes\n", ilen);
744 if (display == 0 || ilen == 0)
745 return;
746 if (D_seql)
747 evdeq(&D_mapev);
748 slen = ilen;
749 s = (unsigned char *)ibuf;
750 while (ilen-- > 0)
751 {
752 ch = *s++;
753 if (D_dontmap || !D_nseqs)
754 {
755 D_dontmap = 0;
756 continue;
757 }
758 for (;;)
759 {
760 debug3("cmp %c %c[%d]\n", ch, *D_seqp, D_seqp - D_kmaps);
761 if (*D_seqp != ch)
762 {
763 l = D_seqp[D_seqp[-D_seql-1] + 1];
764 if (l)
765 {
766 D_seqp += l * 2 + 4;
767 debug1("miss %d\n", D_seqp - D_kmaps);
768 continue;
769 }
770 debug("complete miss\n");
771 D_mapdefault = 0;
772 l = D_seql;
773 p = (char *)D_seqp - l;
774 D_seql = 0;
775 D_seqp = D_kmaps + 3;
776 if (l == 0)
777 break;
778 if ((q = D_seqh) != 0)
779 {
780 D_seqh = 0;
781 i = q[0] << 8 | q[1];
782 i &= ~KMAP_NOTIMEOUT;
783 debug1("Mapping former hit #%d - ", i);
784 debug2("%d(%s) - ", q[2], q + 3);
785 if (StuffKey(i))
786 ProcessInput2((char *)q + 3, q[2]);
787 if (display == 0)
788 return;
789 l -= q[2];
790 p += q[2];
791 }
792 else
793 D_dontmap = 1;
794 debug1("flush old %d\n", l);
795 ProcessInput(p, l);
796 if (display == 0)
797 return;
798 evdeq(&D_mapev);
799 continue;
800 }
801 if (D_seql++ == 0)
802 {
803 /* Finish old stuff */
804 slen -= ilen + 1;
805 debug1("finish old %d\n", slen);
806 if (slen)
807 ProcessInput2(ibuf, slen);
808 if (display == 0)
809 return;
810 D_seqh = 0;
811 }
812 ibuf = (char *)s;
813 slen = ilen;
814 D_seqp++;
815 l = D_seql;
816 debug2("length am %d, want %d\n", l, D_seqp[-l - 1]);
817 if (l == D_seqp[-l - 1])
818 {
819 if (D_seqp[l] != l)
820 {
821 q = D_seqp + 1 + l;
822 if (D_kmaps + D_nseqs > q && q[2] > l && !bcmp(D_seqp - l, q + 3, l))
823 {
824 debug1("have another mapping (%s), delay execution\n", q + 3);
825 D_seqh = D_seqp - 3 - l;
826 D_seqp = q + 3 + l;
827 break;
828 }
829 }
830 i = D_seqp[-l - 3] << 8 | D_seqp[-l - 2];
831 i &= ~KMAP_NOTIMEOUT;
832 debug1("Mapping #%d - ", i);
833 p = (char *)D_seqp - l;
834 debug2("%d(%s) - ", l, p);
835 D_seql = 0;
836 D_seqp = D_kmaps + 3;
837 D_seqh = 0;
838 if (StuffKey(i))
839 ProcessInput2(p, l);
840 if (display == 0)
841 return;
842 }
843 break;
844 }
845 }
846 if (D_seql)
847 {
848 debug("am in sequence -> check for timeout\n");
849 l = D_seql;
850 for (s = D_seqp; ; s += i * 2 + 4)
851 {
852 if (s[-l-3] & KMAP_NOTIMEOUT >> 8)
853 break;
854 if ((i = s[s[-l-1] + 1]) == 0)
855 {
856 SetTimeout(&D_mapev, maptimeout);
857 evenq(&D_mapev);
858 break;
859 }
860 }
861 }
862 ProcessInput2(ibuf, slen);
863 }
864
865 #else
866 # define ProcessInput2 ProcessInput
867 #endif
868
869
870 /*
871 * Here only the screen escape commands are handled.
872 */
873
874 void
875 ProcessInput2(ibuf, ilen)
876 char *ibuf;
877 int ilen;
878 {
879 char *s;
880 int ch, slen;
881 struct action *ktabp;
882
883 debug1("ProcessInput2: %d bytes\n", ilen);
884 while (ilen && display)
885 {
886 debug1(" - ilen now %d bytes\n", ilen);
887 flayer = D_forecv->c_layer;
888 fore = D_fore;
889 slen = ilen;
890 s = ibuf;
891 if (!D_ESCseen)
892 {
893 while (ilen > 0)
894 {
895 if ((unsigned char)*s++ == D_user->u_Esc)
896 break;
897 ilen--;
898 }
899 slen -= ilen;
900 if (slen)
901 DoProcess(fore, &ibuf, &slen, 0);
902 if (--ilen == 0)
903 D_ESCseen = ktab;
904 }
905 if (ilen <= 0)
906 return;
907 ktabp = D_ESCseen ? D_ESCseen : ktab;
908 D_ESCseen = 0;
909 ch = (unsigned char)*s;
910
911 /*
912 * As users have different esc characters, but a common ktab[],
913 * we fold back the users esc and meta-esc key to the Default keys
914 * that can be looked up in the ktab[]. grmbl. jw.
915 * XXX: make ktab[] a per user thing.
916 */
917 if (ch == D_user->u_Esc)
918 ch = DefaultEsc;
919 else if (ch == D_user->u_MetaEsc)
920 ch = DefaultMetaEsc;
921
922 if (ch >= 0)
923 DoAction(&ktabp[ch], ch);
924 ibuf = (char *)(s + 1);
925 ilen--;
926 }
927 }
928
929 void
930 DoProcess(p, bufp, lenp, pa)
931 struct win *p;
932 char **bufp;
933 int *lenp;
934 struct paster *pa;
935 {
936 int oldlen;
937 struct display *d = display;
938
939 #ifdef COPY_PASTE
940 /* XXX -> PasteStart */
941 if (pa && *lenp > 1 && p && p->w_slowpaste)
942 {
943 /* schedule slowpaste event */
944 SetTimeout(&p->w_paster.pa_slowev, p->w_slowpaste);
945 evenq(&p->w_paster.pa_slowev);
946 return;
947 }
948 #endif
949 while (flayer && *lenp)
950 {
951 #ifdef COPY_PASTE
952 if (!pa && p && p->w_paster.pa_pastelen && flayer == p->w_paster.pa_pastelayer)
953 {
954 debug("layer is busy - beep!\n");
955 WBell(p, visual_bell);
956 *bufp += *lenp;
957 *lenp = 0;
958 display = d;
959 return;
960 }
961 #endif
962 oldlen = *lenp;
963 LayProcess(bufp, lenp);
964 #ifdef COPY_PASTE
965 if (pa && !pa->pa_pastelayer)
966 break; /* flush rest of paste */
967 #endif
968 if (*lenp == oldlen)
969 {
970 if (pa)
971 {
972 display = d;
973 return;
974 }
975 /* We're full, let's beep */
976 debug("layer is full - beep!\n");
977 WBell(p, visual_bell);
978 break;
979 }
980 }
981 *bufp += *lenp;
982 *lenp = 0;
983 display = d;
984 #ifdef COPY_PASTE
985 if (pa && pa->pa_pastelen == 0)
986 FreePaster(pa);
987 #endif
988 }
989
990 int
991 FindCommnr(str)
992 char *str;
993 {
994 int x, m, l = 0, r = RC_LAST;
995 while (l <= r)
996 {
997 m = (l + r) / 2;
998 x = strcmp(str, comms[m].name);
999 if (x > 0)
1000 l = m + 1;
1001 else if (x < 0)
1002 r = m - 1;
1003 else
1004 return m;
1005 }
1006 return RC_ILLEGAL;
1007 }
1008
1009 static int
1010 CheckArgNum(nr, args)
1011 int nr;
1012 char **args;
1013 {
1014 int i, n;
1015 static char *argss[] = {"no", "one", "two", "three", "four", "OOPS"};
1016 static char *orformat[] =
1017 {
1018 "%s: %s: %s argument%s required",
1019 "%s: %s: %s or %s argument%s required",
1020 "%s: %s: %s, %s or %s argument%s required",
1021 "%s: %s: %s, %s, %s or %s argument%s required"
1022 };
1023
1024 n = comms[nr].flags & ARGS_MASK;
1025 for (i = 0; args[i]; i++)
1026 ;
1027 if (comms[nr].flags & ARGS_ORMORE)
1028 {
1029 if (i < n)
1030 {
1031 Msg(0, "%s: %s: at least %s argument%s required",
1032 rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1033 return -1;
1034 }
1035 }
1036 else if ((comms[nr].flags & ARGS_PLUS1) &&
1037 (comms[nr].flags & ARGS_PLUS2) &&
1038 (comms[nr].flags & ARGS_PLUS3))
1039 {
1040 if (i != n && i != n + 1 && i != n + 2 && i != n + 3)
1041 {
1042 Msg(0, orformat[3], rc_name, comms[nr].name, argss[n],
1043 argss[n + 1], argss[n + 2], argss[n + 3], "");
1044 return -1;
1045 }
1046 }
1047 else if ((comms[nr].flags & ARGS_PLUS1) &&
1048 (comms[nr].flags & ARGS_PLUS2))
1049 {
1050 if (i != n && i != n + 1 && i != n + 2)
1051 {
1052 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1053 argss[n + 1], argss[n + 2], "");
1054 return -1;
1055 }
1056 }
1057 else if ((comms[nr].flags & ARGS_PLUS1) &&
1058 (comms[nr].flags & ARGS_PLUS3))
1059 {
1060 if (i != n && i != n + 1 && i != n + 3)
1061 {
1062 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1063 argss[n + 1], argss[n + 3], "");
1064 return -1;
1065 }
1066 }
1067 else if ((comms[nr].flags & ARGS_PLUS2) &&
1068 (comms[nr].flags & ARGS_PLUS3))
1069 {
1070 if (i != n && i != n + 2 && i != n + 3)
1071 {
1072 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1073 argss[n + 2], argss[n + 3], "");
1074 return -1;
1075 }
1076 }
1077 else if (comms[nr].flags & ARGS_PLUS1)
1078 {
1079 if (i != n && i != n + 1)
1080 {
1081 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1082 argss[n + 1], n != 0 ? "s" : "");
1083 return -1;
1084 }
1085 }
1086 else if (comms[nr].flags & ARGS_PLUS2)
1087 {
1088 if (i != n && i != n + 2)
1089 {
1090 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1091 argss[n + 2], "s");
1092 return -1;
1093 }
1094 }
1095 else if (comms[nr].flags & ARGS_PLUS3)
1096 {
1097 if (i != n && i != n + 3)
1098 {
1099 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1100 argss[n + 3], "");
1101 return -1;
1102 }
1103 }
1104 else if (i != n)
1105 {
1106 Msg(0, orformat[0], rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1107 return -1;
1108 }
1109 return i;
1110 }
1111
1112 static void
1113 StuffFin(buf, len, data)
1114 char *buf;
1115 int len;
1116 char *data;
1117 {
1118 if (!flayer)
1119 return;
1120 while(len)
1121 LayProcess(&buf, &len);
1122 }
1123
1124 /*ARGSUSED*/
1125 void
1126 DoAction(act, key)
1127 struct action *act;
1128 int key;
1129 {
1130 int nr = act->nr;
1131 char **args = act->args;
1132 int *argl = act->argl;
1133 struct win *p;
1134 int argc, i, n, msgok;
1135 char *s;
1136 char ch;
1137 struct display *odisplay = display;
1138 struct acluser *user;
1139
1140 user = display ? D_user : users;
1141 if (nr == RC_ILLEGAL)
1142 {
1143 debug1("key '%c': No action\n", key);
1144 return;
1145 }
1146 n = comms[nr].flags;
1147 if ((n & NEED_DISPLAY) && display == 0)
1148 {
1149 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
1150 return;
1151 }
1152 if ((n & NEED_FORE) && fore == 0)
1153 {
1154 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
1155 return;
1156 }
1157 if ((n & NEED_LAYER) && flayer == 0)
1158 {
1159 Msg(0, "%s: %s: display or window required", rc_name, comms[nr].name);
1160 return;
1161 }
1162 if ((argc = CheckArgNum(nr, args)) < 0)
1163 return;
1164 #ifdef MULTIUSER
1165 if (display)
1166 {
1167 if (AclCheckPermCmd(D_user, ACL_EXEC, &comms[nr]))
1168 {
1169 Msg(0, "%s: %s: permission denied (user %s)",
1170 rc_name, comms[nr].name, (EffectiveAclUser ? EffectiveAclUser : D_user)->u_name);
1171 return;
1172 }
1173 }
1174 #endif /* MULTIUSER */
1175
1176 msgok = display && !*rc_name;
1177 switch(nr)
1178 {
1179 case RC_SELECT:
1180 if (!*args)
1181 InputSelect();
1182 else if (args[0][0] == '-' && !args[0][1])
1183 {
1184 SetForeWindow((struct win *)0);
1185 Activate(0);
1186 }
1187 else if (args[0][0] == '.' && !args[0][1])
1188 {
1189 if (!fore)
1190 Msg(0, "select . needs a window");
1191 else
1192 {
1193 SetForeWindow(fore);
1194 Activate(0);
1195 }
1196 }
1197 else if (ParseWinNum(act, &n) == 0)
1198 SwitchWindow(n);
1199 break;
1200 #ifdef AUTO_NUKE
1201 case RC_DEFAUTONUKE:
1202 if (ParseOnOff(act, &defautonuke) == 0 && msgok)
1203 Msg(0, "Default autonuke turned %s", defautonuke ? "on" : "off");
1204 if (display && *rc_name)
1205 D_auto_nuke = defautonuke;
1206 break;
1207 case RC_AUTONUKE:
1208 if (ParseOnOff(act, &D_auto_nuke) == 0 && msgok)
1209 Msg(0, "Autonuke turned %s", D_auto_nuke ? "on" : "off");
1210 break;
1211 #endif
1212 case RC_DEFOBUFLIMIT:
1213 if (ParseNum(act, &defobuflimit) == 0 && msgok)
1214 Msg(0, "Default limit set to %d", defobuflimit);
1215 if (display && *rc_name)
1216 {
1217 D_obufmax = defobuflimit;
1218 D_obuflenmax = D_obuflen - D_obufmax;
1219 }
1220 break;
1221 case RC_OBUFLIMIT:
1222 if (*args == 0)
1223 Msg(0, "Limit is %d, current buffer size is %d", D_obufmax, D_obuflen);
1224 else if (ParseNum(act, &D_obufmax) == 0 && msgok)
1225 Msg(0, "Limit set to %d", D_obufmax);
1226 D_obuflenmax = D_obuflen - D_obufmax;
1227 break;
1228 case RC_DUMPTERMCAP:
1229 WriteFile(user, (char *)0, DUMP_TERMCAP);
1230 break;
1231 case RC_HARDCOPY:
1232 {
1233 int mode = DUMP_HARDCOPY;
1234
1235 if (argc > 1 && !strcmp(*args, "-h"))
1236 {
1237 mode = DUMP_SCROLLBACK;
1238 args++;
1239 argc--;
1240 }
1241 if (*args && args[1])
1242 {
1243 Msg(0, "%s: hardcopy: too many arguments", rc_name);
1244 break;
1245 }
1246 if (fore == 0 && *args == 0)
1247 Msg(0, "%s: hardcopy: window required", rc_name);
1248 else
1249 WriteFile(user, *args, mode);
1250 }
1251 break;
1252 case RC_DEFLOG:
1253 (void)ParseOnOff(act, &nwin_default.Lflag);
1254 break;
1255 case RC_LOG:
1256 n = fore->w_log ? 1 : 0;
1257 ParseSwitch(act, &n);
1258 LogToggle(n);
1259 break;
1260 #ifdef BSDJOBS
1261 case RC_SUSPEND:
1262 Detach(D_STOP);
1263 break;
1264 #endif
1265 case RC_NEXT:
1266 if (MoreWindows())
1267 SwitchWindow(NextWindow());
1268 break;
1269 case RC_PREV:
1270 if (MoreWindows())
1271 SwitchWindow(PreviousWindow());
1272 break;
1273 case RC_KILL:
1274 {
1275 char *name;
1276
1277 if (key >= 0)
1278 {
1279 #ifdef PSEUDOS
1280 Input(fore->w_pwin ? "Really kill this filter [y/n]" : "Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1281 #else
1282 Input("Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1283 #endif
1284 break;
1285 }
1286 n = fore->w_number;
1287 #ifdef PSEUDOS
1288 if (fore->w_pwin)
1289 {
1290 FreePseudowin(fore);
1291 Msg(0, "Filter removed.");
1292 break;
1293 }
1294 #endif
1295 name = SaveStr(fore->w_title);
1296 KillWindow(fore);
1297 Msg(0, "Window %d (%s) killed.", n, name);
1298 if (name)
1299 free(name);
1300 break;
1301 }
1302 case RC_QUIT:
1303 if (key >= 0)
1304 {
1305 Input("Really quit and kill all your windows [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_QUIT);
1306 break;
1307 }
1308 Finit(0);
1309 /* NOTREACHED */
1310 #ifdef DETACH
1311 case RC_DETACH:
1312 if (*args && !strcmp(*args, "-h"))
1313 Hangup();
1314 else
1315 Detach(D_DETACH);
1316 break;
1317 # ifdef POW_DETACH
1318 case RC_POW_DETACH:
1319 if (key >= 0)
1320 {
1321 static char buf[2];
1322
1323 buf[0] = key;
1324 Input(buf, 1, INP_RAW, pow_detach_fn, NULL, 0);
1325 }
1326 else
1327 Detach(D_POWER); /* detach and kill Attacher's parent */
1328 break;
1329 # endif
1330 #endif
1331 case RC_DEBUG:
1332 #ifdef DEBUG
1333 if (!*args)
1334 {
1335 if (dfp)
1336 Msg(0, "debugging info is written to %s/", DEBUGDIR);
1337 else
1338 Msg(0, "debugging is currently off. Use 'debug on' to enable.");
1339 break;
1340 }
1341 if (dfp)
1342 {
1343 debug("debug: closing debug file.\n");
1344 fflush(dfp);
1345 fclose(dfp);
1346 dfp = NULL;
1347 }
1348 if (strcmp("off", *args))
1349 opendebug(0, 1);
1350 # ifdef SIG_NODEBUG
1351 else if (display)
1352 kill(D_userpid, SIG_NODEBUG); /* a one shot item, but hey... */
1353 # endif /* SIG_NODEBUG */
1354 #else
1355 if (*args == 0 || strcmp("off", *args))
1356 Msg(0, "Sorry, screen was compiled without -DDEBUG option.");
1357 #endif
1358 break;
1359 #ifdef ZMODEM
1360 case RC_ZMODEM:
1361 if (*args && !strcmp(*args, "sendcmd"))
1362 {
1363 if (args[1])
1364 {
1365 free(zmodem_sendcmd);
1366 zmodem_sendcmd = SaveStr(args[1]);
1367 }
1368 if (msgok)
1369 Msg(0, "zmodem sendcmd: %s", zmodem_sendcmd);
1370 break;
1371 }
1372 if (*args && !strcmp(*args, "recvcmd"))
1373 {
1374 if (args[1])
1375 {
1376 free(zmodem_recvcmd);
1377 zmodem_recvcmd = SaveStr(args[1]);
1378 }
1379 if (msgok)
1380 Msg(0, "zmodem recvcmd: %s", zmodem_recvcmd);
1381 break;
1382 }
1383 if (*args)
1384 {
1385 for (i = 0; i < 4; i++)
1386 if (!strcmp(zmodes[i], *args))
1387 break;
1388 if (i == 4 && !strcmp(*args, "on"))
1389 i = 1;
1390 if (i == 4)
1391 {
1392 Msg(0, "usage: zmodem off|auto|catch|pass");
1393 break;
1394 }
1395 zmodem_mode = i;
1396 }
1397 if (msgok)
1398 Msg(0, "zmodem mode is %s", zmodes[zmodem_mode]);
1399 break;
1400 #endif
1401 case RC_UNBINDALL:
1402 {
1403 register unsigned int i;
1404
1405 for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++)
1406 ClearAction(&ktab[i]);
1407 Msg(0, "Unbound all keys." );
1408 break;
1409 }
1410 case RC_ZOMBIE:
1411 {
1412 if (!(s = *args))
1413 {
1414 ZombieKey_destroy = 0;
1415 break;
1416 }
1417 if (*argl == 0 || *argl > 2)
1418 {
1419 Msg(0, "%s:zombie: one or two characters expected.", rc_name);
1420 break;
1421 }
1422 if (args[1])
1423 {
1424 if (!strcmp(args[1], "onerror"))
1425 {
1426 ZombieKey_onerror = 1;
1427 } else {
1428 Msg(0, "usage: zombie [keys [onerror]]");
1429 break;
1430 }
1431 } else
1432 ZombieKey_onerror = 0;
1433 ZombieKey_destroy = args[0][0];
1434 ZombieKey_resurrect = *argl == 2 ? args[0][1] : 0;
1435 }
1436 break;
1437 case RC_WALL:
1438 #ifdef MULTIUSER
1439 s = D_user->u_name;
1440 #else
1441 s = D_usertty;
1442 #endif
1443 {
1444 struct display *olddisplay = display;
1445 display = 0; /* no display will cause a broadcast */
1446 Msg(0, "%s: %s", s, *args);
1447 display = olddisplay;
1448 }
1449 break;
1450 case RC_AT:
1451 /* where this AT command comes from: */
1452 #ifdef MULTIUSER
1453 s = SaveStr(D_user->u_name);
1454 /* DO NOT RETURN FROM HERE WITHOUT RESETTING THIS: */
1455 EffectiveAclUser = D_user;
1456 #else
1457 s = SaveStr(D_usertty);
1458 #endif
1459 n = strlen(args[0]);
1460 if (n) n--;
1461 /*
1462 * the windows/displays loops are quite dangerous here, take extra
1463 * care not to trigger landmines. Things may appear/disappear while
1464 * we are walking along.
1465 */
1466 switch (args[0][n])
1467 {
1468 case '*': /* user */
1469 {
1470 struct display *nd;
1471 struct acluser *u;
1472
1473 if (!n)
1474 u = D_user;
1475 else
1476 for (u = users; u; u = u->u_next)
1477 {
1478 debug3("strncmp('%s', '%s', %d)\n", *args, u->u_name, n);
1479 if (!strncmp(*args, u->u_name, n))
1480 break;
1481 }
1482 debug1("at all displays of user %s\n", u->u_name);
1483 for (display = displays; display; display = nd)
1484 {
1485 nd = display->d_next;
1486 if (D_forecv == 0)
1487 continue;
1488 flayer = D_forecv->c_layer;
1489 fore = D_fore;
1490 if (D_user != u)
1491 continue;
1492 debug1("AT display %s\n", D_usertty);
1493 DoCommand(args + 1, argl + 1);
1494 if (display)
1495 Msg(0, "command from %s: %s %s",
1496 s, args[1], args[2] ? args[2] : "");
1497 display = NULL;
1498 flayer = 0;
1499 fore = NULL;
1500 }
1501 break;
1502 }
1503 case '%': /* display */
1504 {
1505 struct display *nd;
1506
1507 debug1("at display matching '%s'\n", args[0]);
1508 for (display = displays; display; display = nd)
1509 {
1510 nd = display->d_next;
1511 if (D_forecv == 0)
1512 continue;
1513 fore = D_fore;
1514 flayer = D_forecv->c_layer;
1515 if (strncmp(args[0], D_usertty, n) &&
1516 (strncmp("/dev/", D_usertty, 5) ||
1517 strncmp(args[0], D_usertty + 5, n)) &&
1518 (strncmp("/dev/tty", D_usertty, 8) ||
1519 strncmp(args[0], D_usertty + 8, n)))
1520 continue;
1521 debug1("AT display %s\n", D_usertty);
1522 DoCommand(args + 1, argl + 1);
1523 if (display)
1524 Msg(0, "command from %s: %s %s",
1525 s, args[1], args[2] ? args[2] : "");
1526 display = NULL;
1527 fore = NULL;
1528 flayer = 0;
1529 }
1530 break;
1531 }
1532 case '#': /* window */
1533 n--;
1534 /* FALLTHROUGH */
1535 default:
1536 {
1537 struct win *nw;
1538 int ch;
1539
1540 n++;
1541 ch = args[0][n];
1542 args[0][n] = '\0';
1543 if (!*args[0] || (i = WindowByNumber(args[0])) < 0)
1544 {
1545 args[0][n] = ch; /* must restore string in case of bind */
1546 /* try looping over titles */
1547 for (fore = windows; fore; fore = nw)
1548 {
1549 nw = fore->w_next;
1550 if (strncmp(args[0], fore->w_title, n))
1551 continue;
1552 debug2("AT window %d(%s)\n", fore->w_number, fore->w_title);
1553 /*
1554 * consider this a bug or a feature:
1555 * while looping through windows, we have fore AND
1556 * display context. This will confuse users who try to
1557 * set up loops inside of loops, but often allows to do
1558 * what you mean, even when you adress your context wrong.
1559 */
1560 i = 0;
1561 /* XXX: other displays? */
1562 if (fore->w_layer.l_cvlist)
1563 display = fore->w_layer.l_cvlist->c_display;
1564 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1565 DoCommand(args + 1, argl + 1); /* may destroy our display */
1566 if (fore && fore->w_layer.l_cvlist)
1567 {
1568 display = fore->w_layer.l_cvlist->c_display;
1569 Msg(0, "command from %s: %s %s",
1570 s, args[1], args[2] ? args[2] : "");
1571 }
1572 }
1573 display = NULL;
1574 fore = NULL;
1575 if (i < 0)
1576 Msg(0, "%s: at '%s': no such window.\n", rc_name, args[0]);
1577 break;
1578 }
1579 else if (i < MAXWIN && (fore = wtab[i]))
1580 {
1581 args[0][n] = ch; /* must restore string in case of bind */
1582 debug2("AT window %d (%s)\n", fore->w_number, fore->w_title);
1583 if (fore->w_layer.l_cvlist)
1584 display = fore->w_layer.l_cvlist->c_display;
1585 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1586 DoCommand(args + 1, argl + 1);
1587 if (fore && fore->w_layer.l_cvlist)
1588 {
1589 display = fore->w_layer.l_cvlist->c_display;
1590 Msg(0, "command from %s: %s %s",
1591 s, args[1], args[2] ? args[2] : "");
1592 }
1593 display = NULL;
1594 fore = NULL;
1595 }
1596 else
1597 Msg(0, "%s: at [identifier][%%|*|#] command [args]", rc_name);
1598 break;
1599 }
1600 }
1601 free(s);
1602 #ifdef MULTIUSER
1603 EffectiveAclUser = NULL;
1604 #endif
1605 break;
1606
1607 #ifdef COPY_PASTE
1608 case RC_READREG:
1609 #ifdef ENCODINGS
1610 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1611 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1612 {
1613 i = FindEncoding(args[1]);
1614 if (i == -1)
1615 {
1616 Msg(0, "%s: readreg: unknown encoding", rc_name);
1617 break;
1618 }
1619 args += 2;
1620 }
1621 #endif
1622 /*
1623 * Without arguments we prompt for a destination register.
1624 * It will receive the copybuffer contents.
1625 * This is not done by RC_PASTE, as we prompt for source
1626 * (not dest) there.
1627 */
1628 if ((s = *args) == NULL)
1629 {
1630 Input("Copy to register:", 1, INP_RAW, copy_reg_fn, NULL, 0);
1631 break;
1632 }
1633 if (*argl != 1)
1634 {
1635 Msg(0, "%s: copyreg: character, ^x, or (octal) \\032 expected.", rc_name);
1636 break;
1637 }
1638 ch = args[0][0];
1639 /*
1640 * With two arguments we *really* read register contents from file
1641 */
1642 if (args[1])
1643 {
1644 if (args[2])
1645 {
1646 Msg(0, "%s: readreg: too many arguments", rc_name);
1647 break;
1648 }
1649 if ((s = ReadFile(args[1], &n)))
1650 {
1651 struct plop *pp = plop_tab + (int)(unsigned char)ch;
1652
1653 if (pp->buf)
1654 free(pp->buf);
1655 pp->buf = s;
1656 pp->len = n;
1657 #ifdef ENCODINGS
1658 pp->enc = i;
1659 #endif
1660 }
1661 }
1662 else
1663 /*
1664 * with one argument we copy the copybuffer into a specified register
1665 * This could be done with RC_PASTE too, but is here to be consistent
1666 * with the zero argument call.
1667 */
1668 copy_reg_fn(&ch, 0, NULL);
1669 break;
1670 #endif
1671 case RC_REGISTER:
1672 #ifdef ENCODINGS
1673 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1674 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1675 {
1676 i = FindEncoding(args[1]);
1677 if (i == -1)
1678 {
1679 Msg(0, "%s: register: unknown encoding", rc_name);
1680 break;
1681 }
1682 args += 2;
1683 argc -= 2;
1684 }
1685 #endif
1686 if (argc != 2)
1687 {
1688 Msg(0, "%s: register: illegal number of arguments.", rc_name);
1689 break;
1690 }
1691 if (*argl != 1)
1692 {
1693 Msg(0, "%s: register: character, ^x, or (octal) \\032 expected.", rc_name);
1694 break;
1695 }
1696 ch = args[0][0];
1697 #ifdef COPY_PASTE
1698 if (ch == '.')
1699 {
1700 if (user->u_plop.buf != NULL)
1701 UserFreeCopyBuffer(user);
1702 if (args[1] && args[1][0])
1703 {
1704 user->u_plop.buf = SaveStrn(args[1], argl[1]);
1705 user->u_plop.len = argl[1];
1706 #ifdef ENCODINGS
1707 user->u_plop.enc = i;
1708 #endif
1709 }
1710 }
1711 else
1712 #endif
1713 {
1714 struct plop *plp = plop_tab + (int)(unsigned char)ch;
1715
1716 if (plp->buf)
1717 free(plp->buf);
1718 plp->buf = SaveStrn(args[1], argl[1]);
1719 plp->len = argl[1];
1720 #ifdef ENCODINGS
1721 plp->enc = i;
1722 #endif
1723 }
1724 break;
1725 case RC_PROCESS:
1726 if ((s = *args) == NULL)
1727 {
1728 Input("Process register:", 1, INP_RAW, process_fn, NULL, 0);
1729 break;
1730 }
1731 if (*argl != 1)
1732 {
1733 Msg(0, "%s: process: character, ^x, or (octal) \\032 expected.", rc_name);
1734 break;
1735 }
1736 ch = args[0][0];
1737 process_fn(&ch, 0, NULL);
1738 break;
1739 case RC_STUFF:
1740 s = *args;
1741 if (!args[0])
1742 {
1743 Input("Stuff:", 100, INP_COOKED, StuffFin, NULL, 0);
1744 break;
1745 }
1746 n = *argl;
1747 if (args[1])
1748 {
1749 if (strcmp(s, "-k"))
1750 {
1751 Msg(0, "%s: stuff: invalid option %s", rc_name, s);
1752 break;
1753 }
1754 s = args[1];
1755 for (i = T_CAPS; i < T_OCAPS; i++)
1756 if (strcmp(term[i].tcname, s) == 0)
1757 break;
1758 if (i == T_OCAPS)
1759 {
1760 Msg(0, "%s: stuff: unknown key '%s'", rc_name, s);
1761 break;
1762 }
1763 #ifdef MAPKEYS
1764 if (StuffKey(i - T_CAPS) == 0)
1765 break;
1766 #endif
1767 s = display ? D_tcs[i].str : 0;
1768 if (s == 0)
1769 break;
1770 n = strlen(s);
1771 }
1772 while(n)
1773 LayProcess(&s, &n);
1774 break;
1775 case RC_REDISPLAY:
1776 Activate(-1);
1777 break;
1778 case RC_WINDOWS:
1779 ShowWindows(-1);
1780 break;
1781 case RC_VERSION:
1782 Msg(0, "screen %s", version);
1783 break;
1784 case RC_TIME:
1785 if (*args)
1786 {
1787 timestring = SaveStr(*args);
1788 break;
1789 }
1790 Msg(0, "%s", MakeWinMsg(timestring, fore, '%'));
1791 break;
1792 case RC_INFO:
1793 ShowInfo();
1794 break;
1795 case RC_DINFO:
1796 ShowDInfo();
1797 break;
1798 case RC_COMMAND:
1799 {
1800 struct action *ktabp = ktab;
1801 if (argc == 2 && !strcmp(*args, "-c"))
1802 {
1803 if ((ktabp = FindKtab(args[1], 0)) == 0)
1804 {
1805 Msg(0, "Unknown command class '%s'", args[1]);
1806 break;
1807 }
1808 }
1809 if (D_ESCseen != ktab || ktabp != ktab)
1810 {
1811 D_ESCseen = ktabp;
1812 break;
1813 }
1814 D_ESCseen = 0;
1815 }
1816 /* FALLTHROUGH */
1817 case RC_OTHER:
1818 if (MoreWindows())
1819 SwitchWindow(display && D_other ? D_other->w_number : NextWindow());
1820 break;
1821 case RC_META:
1822 if (user->u_Esc == -1)
1823 break;
1824 ch = user->u_Esc;
1825 s = &ch;
1826 n = 1;
1827 LayProcess(&s, &n);
1828 break;
1829 case RC_XON:
1830 ch = Ctrl('q');
1831 s = &ch;
1832 n = 1;
1833 LayProcess(&s, &n);
1834 break;
1835 case RC_XOFF:
1836 ch = Ctrl('s');
1837 s = &ch;
1838 n = 1;
1839 LayProcess(&s, &n);
1840 break;
1841 case RC_DEFBREAKTYPE:
1842 case RC_BREAKTYPE:
1843 {
1844 static char *types[] = { "TIOCSBRK", "TCSBRK", "tcsendbreak", NULL };
1845 extern int breaktype;
1846
1847 if (*args)
1848 {
1849 if (ParseNum(act, &n))
1850 for (n = 0; n < (int)(sizeof(types)/sizeof(*types)); n++)
1851 {
1852 for (i = 0; i < 4; i++)
1853 {
1854 ch = args[0][i];
1855 if (ch >= 'a' && ch <= 'z')
1856 ch -= 'a' - 'A';
1857 if (ch != types[n][i] && (ch + ('a' - 'A')) != types[n][i])
1858 break;
1859 }
1860 if (i == 4)
1861 break;
1862 }
1863 if (n < 0 || n >= (int)(sizeof(types)/sizeof(*types)))
1864 Msg(0, "%s invalid, chose one of %s, %s or %s", *args, types[0], types[1], types[2]);
1865 else
1866 {
1867 breaktype = n;
1868 Msg(0, "breaktype set to (%d) %s", n, types[n]);
1869 }
1870 }
1871 else
1872 Msg(0, "breaktype is (%d) %s", breaktype, types[breaktype]);
1873 }
1874 break;
1875 case RC_POW_BREAK:
1876 case RC_BREAK:
1877 n = 0;
1878 if (*args && ParseNum(act, &n))
1879 break;
1880 SendBreak(fore, n, nr == RC_POW_BREAK);
1881 break;
1882 #ifdef LOCK
1883 case RC_LOCKSCREEN:
1884 Detach(D_LOCK);
1885 break;
1886 #endif
1887 case RC_WIDTH:
1888 case RC_HEIGHT:
1889 {
1890 int w, h;
1891 int what = 0;
1892
1893 i = 1;
1894 if (*args && !strcmp(*args, "-w"))
1895 what = 1;
1896 else if (*args && !strcmp(*args, "-d"))
1897 what = 2;
1898 if (what)
1899 args++;
1900 if (what == 0 && flayer && !display)
1901 what = 1;
1902 if (what == 1)
1903 {
1904 if (!flayer)
1905 {
1906 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
1907 break;
1908 }
1909 w = flayer->l_width;
1910 h = flayer->l_height;
1911 }
1912 else
1913 {
1914 if (!display)
1915 {
1916 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
1917 break;
1918 }
1919 w = D_width;
1920 h = D_height;
1921 }
1922 if (*args && args[0][0] == '-')
1923 {
1924 Msg(0, "%s: %s: unknown option %s", rc_name, comms[nr].name, *args);
1925 break;
1926 }
1927 if (nr == RC_HEIGHT)
1928 {
1929 if (!*args)
1930 {
1931 #define H0height 42
1932 #define H1height 24
1933 if (h == H0height)
1934 h = H1height;
1935 else if (h == H1height)
1936 h = H0height;
1937 else if (h > (H0height + H1height) / 2)
1938 h = H0height;
1939 else
1940 h = H1height;
1941 }
1942 else
1943 {
1944 h = atoi(*args);
1945 if (args[1])
1946 w = atoi(args[1]);
1947 }
1948 }
1949 else
1950 {
1951 if (!*args)
1952 {
1953 if (w == Z0width)
1954 w = Z1width;
1955 else if (w == Z1width)
1956 w = Z0width;
1957 else if (w > (Z0width + Z1width) / 2)
1958 w = Z0width;
1959 else
1960 w = Z1width;
1961 }
1962 else
1963 {
1964 w = atoi(*args);
1965 if (args[1])
1966 h = atoi(args[1]);
1967 }
1968 }
1969 if (*args && args[1] && args[2])
1970 {
1971 Msg(0, "%s: %s: too many arguments", rc_name, comms[nr].name);
1972 break;
1973 }
1974 if (w <= 0)
1975 {
1976 Msg(0, "Illegal width");
1977 break;
1978 }
1979 if (h <= 0)
1980 {
1981 Msg(0, "Illegal height");
1982 break;
1983 }
1984 if (what == 1)
1985 {
1986 if (flayer->l_width == w && flayer->l_height == h)
1987 break;
1988 ResizeLayer(flayer, w, h, (struct display *)0);
1989 break;
1990 }
1991 if (D_width == w && D_height == h)
1992 break;
1993 if (what == 2)
1994 {
1995 ChangeScreenSize(w, h, 1);
1996 }
1997 else
1998 {
1999 if (ResizeDisplay(w, h) == 0)
2000 {
2001 Activate(D_fore ? D_fore->w_norefresh : 0);
2002 /* autofit */
2003 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
2004 break;
2005 }
2006 if (h == D_height)
2007 Msg(0, "Your termcap does not specify how to change the terminal's width to %d.", w);
2008 else if (w == D_width)
2009 Msg(0, "Your termcap does not specify how to change the terminal's height to %d.", h);
2010 else
2011 Msg(0, "Your termcap does not specify how to change the terminal's resolution to %dx%d.", w, h);
2012 }
2013 }
2014 break;
2015 case RC_TITLE:
2016 if (*args == 0)
2017 InputAKA();
2018 else
2019 ChangeAKA(fore, *args, strlen(*args));
2020 break;
2021 case RC_COLON:
2022 Input(":", 100, INP_EVERY, Colonfin, NULL, 0);
2023 if (*args && **args)
2024 {
2025 s = *args;
2026 n = strlen(s);
2027 LayProcess(&s, &n);
2028 }
2029 break;
2030 case RC_LASTMSG:
2031 if (D_status_lastmsg)
2032 Msg(0, "%s", D_status_lastmsg);
2033 break;
2034 case RC_SCREEN:
2035 DoScreen("key", args);
2036 break;
2037 case RC_WRAP:
2038 if (ParseSwitch(act, &fore->w_wrap) == 0 && msgok)
2039 Msg(0, "%cwrap", fore->w_wrap ? '+' : '-');
2040 break;
2041 case RC_FLOW:
2042 if (*args)
2043 {
2044 if (args[0][0] == 'a')
2045 {
2046 fore->w_flow = (fore->w_flow & FLOW_AUTO) ? FLOW_AUTOFLAG |FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2047 }
2048 else
2049 {
2050 if (ParseOnOff(act, &n))
2051 break;
2052 fore->w_flow = (fore->w_flow & FLOW_AUTO) | n;
2053 }
2054 }
2055 else
2056 {
2057 if (fore->w_flow & FLOW_AUTOFLAG)
2058 fore->w_flow = (fore->w_flow & FLOW_AUTO) | FLOW_NOW;
2059 else if (fore->w_flow & FLOW_NOW)
2060 fore->w_flow &= ~FLOW_NOW;
2061 else
2062 fore->w_flow = fore->w_flow ? FLOW_AUTOFLAG|FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2063 }
2064 SetFlow(fore->w_flow & FLOW_NOW);
2065 if (msgok)
2066 Msg(0, "%cflow%s", (fore->w_flow & FLOW_NOW) ? '+' : '-',
2067 (fore->w_flow & FLOW_AUTOFLAG) ? "(auto)" : "");
2068 break;
2069 #ifdef MULTIUSER
2070 case RC_DEFWRITELOCK:
2071 if (args[0][0] == 'a')
2072 nwin_default.wlock = WLOCK_AUTO;
2073 else
2074 {
2075 if (ParseOnOff(act, &n))
2076 break;
2077 nwin_default.wlock = n ? WLOCK_ON : WLOCK_OFF;
2078 }
2079 break;
2080 case RC_WRITELOCK:
2081 if (*args)
2082 {
2083 if (args[0][0] == 'a')
2084 {
2085 fore->w_wlock = WLOCK_AUTO;
2086 }
2087 else
2088 {
2089 if (ParseOnOff(act, &n))
2090 break;
2091 fore->w_wlock = n ? WLOCK_ON : WLOCK_OFF;
2092 }
2093 /*
2094 * user may have permission to change the writelock setting,
2095 * but he may never aquire the lock himself without write permission
2096 */
2097 if (!AclCheckPermWin(D_user, ACL_WRITE, fore))
2098 fore->w_wlockuser = D_user;
2099 }
2100 Msg(0, "writelock %s", (fore->w_wlock == WLOCK_AUTO) ? "auto" :
2101 ((fore->w_wlock == WLOCK_OFF) ? "off" : "on"));
2102 break;
2103 #endif
2104 case RC_CLEAR:
2105 ResetAnsiState(fore);
2106 WriteString(fore, "\033[H\033[J", 6);
2107 break;
2108 case RC_RESET:
2109 ResetAnsiState(fore);
2110 #ifdef ZMODEM
2111 if (fore->w_zdisplay)
2112 zmodem_abort(fore, fore->w_zdisplay);
2113 #endif
2114 WriteString(fore, "\033c", 2);
2115 break;
2116 case RC_MONITOR:
2117 n = fore->w_monitor != MON_OFF;
2118 #ifdef MULTIUSER
2119 if (display)
2120 n = n && (ACLBYTE(fore->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id));
2121 #endif
2122 if (ParseSwitch(act, &n))
2123 break;
2124 if (n)
2125 {
2126 #ifdef MULTIUSER
2127 if (display) /* we tell only this user */
2128 ACLBYTE(fore->w_mon_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2129 else
2130 for (i = 0; i < maxusercount; i++)
2131 ACLBYTE(fore->w_mon_notify, i) |= ACLBIT(i);
2132 #endif
2133 if (fore->w_monitor == MON_OFF)
2134 fore->w_monitor = MON_ON;
2135 Msg(0, "Window %d (%s) is now being monitored for all activity.", fore->w_number, fore->w_title);
2136 }
2137 else
2138 {
2139 #ifdef MULTIUSER
2140 if (display) /* we remove only this user */
2141 ACLBYTE(fore->w_mon_notify, D_user->u_id)
2142 &= ~ACLBIT(D_user->u_id);
2143 else
2144 for (i = 0; i < maxusercount; i++)
2145 ACLBYTE(fore->w_mon_notify, i) &= ~ACLBIT(i);
2146 for (i = maxusercount - 1; i >= 0; i--)
2147 if (ACLBYTE(fore->w_mon_notify, i))
2148 break;
2149 if (i < 0)
2150 #endif
2151 fore->w_monitor = MON_OFF;
2152 Msg(0, "Window %d (%s) is no longer being monitored for activity.", fore->w_number, fore->w_title);
2153 }
2154 break;
2155 #ifdef MULTI
2156 case RC_DISPLAYS:
2157 display_displays();
2158 break;
2159 #endif
2160 case RC_WINDOWLIST:
2161 if (!*args)
2162 display_wlist(0, WLIST_NUM, (struct win *)0);
2163 else if (!strcmp(*args, "string"))
2164 {
2165 if (args[1])
2166 {
2167 if (wliststr)
2168 free(wliststr);
2169 wliststr = SaveStr(args[1]);
2170 }
2171 if (msgok)
2172 Msg(0, "windowlist string is '%s'", wliststr);
2173 }
2174 else if (!strcmp(*args, "title"))
2175 {
2176 if (args[1])
2177 {
2178 if (wlisttit)
2179 free(wlisttit);
2180 wlisttit = SaveStr(args[1]);
2181 }
2182 if (msgok)
2183 Msg(0, "windowlist title is '%s'", wlisttit);
2184 }
2185 else
2186 {
2187 int flag = 0;
2188 int blank = 0;
2189 for (i = 0; i < argc; i++)
2190 if (!args[i])
2191 continue;
2192 else if (!strcmp(args[i], "-m"))
2193 flag |= WLIST_MRU;
2194 else if (!strcmp(args[i], "-b"))
2195 blank = 1;
2196 else if (!strcmp(args[i], "-g"))
2197 flag |= WLIST_NESTED;
2198 else
2199 {
2200 Msg(0, "usage: windowlist [-b] [-g] [-m] [string [string] | title [title]]");
2201 break;
2202 }
2203 if (i == argc)
2204 display_wlist(blank, flag, (struct win *)0);
2205 }
2206 break;
2207 case RC_HELP:
2208 if (argc == 2 && !strcmp(*args, "-c"))
2209 {
2210 struct action *ktabp;
2211 if ((ktabp = FindKtab(args[1], 0)) == 0)
2212 {
2213 Msg(0, "Unknown command class '%s'", args[1]);
2214 break;
2215 }
2216 display_help(args[1], ktabp);
2217 }
2218 else
2219 display_help((char *)0, ktab);
2220 break;
2221 case RC_LICENSE:
2222 display_copyright();
2223 break;
2224 #ifdef COPY_PASTE
2225 case RC_COPY:
2226 if (flayer->l_layfn != &WinLf)
2227 {
2228 Msg(0, "Must be on a window layer");
2229 break;
2230 }
2231 MarkRoutine();
2232 break;
2233 case RC_HISTORY:
2234 {
2235 static char *pasteargs[] = {".", 0};
2236 static int pasteargl[] = {1};
2237
2238 if (flayer->l_layfn != &WinLf)
2239 {
2240 Msg(0, "Must be on a window layer");
2241 break;
2242 }
2243 if (GetHistory() == 0)
2244 break;
2245 if (user->u_plop.buf == NULL)
2246 break;
2247 args = pasteargs;
2248 argl = pasteargl;
2249 }
2250 /*FALLTHROUGH*/
2251 case RC_PASTE:
2252 {
2253 char *ss, *dbuf, dch;
2254 int l = 0;
2255 # ifdef ENCODINGS
2256 int enc = -1;
2257 # endif
2258
2259 /*
2260 * without args we prompt for one(!) register to be pasted in the window
2261 */
2262 if ((s = *args) == NULL)
2263 {
2264 Input("Paste from register:", 1, INP_RAW, ins_reg_fn, NULL, 0);
2265 break;
2266 }
2267 if (args[1] == 0 && !fore) /* no window? */
2268 break;
2269 /*
2270 * with two arguments we paste into a destination register
2271 * (no window needed here).
2272 */
2273 if (args[1] && argl[1] != 1)
2274 {
2275 Msg(0, "%s: paste destination: character, ^x, or (octal) \\032 expected.",
2276 rc_name);
2277 break;
2278 }
2279 # ifdef ENCODINGS
2280 else if (fore)
2281 enc = fore->w_encoding;
2282 # endif
2283
2284 /*
2285 * measure length of needed buffer
2286 */
2287 for (ss = s = *args; (ch = *ss); ss++)
2288 {
2289 if (ch == '.')
2290 {
2291 # ifdef ENCODINGS
2292 if (enc == -1)
2293 enc = user->u_plop.enc;
2294 if (enc != user->u_plop.enc)
2295 l += RecodeBuf((unsigned char *)user->u_plop.buf, user->u_plop.len, user->u_plop.enc, enc, (unsigned char *)0);
2296 else
2297 # endif
2298 l += user->u_plop.len;
2299 }
2300 else
2301 {
2302 # ifdef ENCODINGS
2303 if (enc == -1)
2304 enc = plop_tab[(int)(unsigned char)ch].enc;
2305 if (enc != plop_tab[(int)(unsigned char)ch].enc)
2306 l += RecodeBuf((unsigned char *)plop_tab[(int)(unsigned char)ch].buf, plop_tab[(int)(unsigned char)ch].len, plop_tab[(int)(unsigned char)ch].enc, enc, (unsigned char *)0);
2307 else
2308 # endif
2309 l += plop_tab[(int)(unsigned char)ch].len;
2310 }
2311 }
2312 if (l == 0)
2313 {
2314 Msg(0, "empty buffer");
2315 break;
2316 }
2317 /*
2318 * shortcut:
2319 * if there is only one source and the destination is a window, then
2320 * pass a pointer rather than duplicating the buffer.
2321 */
2322 if (s[1] == 0 && args[1] == 0)
2323 # ifdef ENCODINGS
2324 if (enc == (*s == '.' ? user->u_plop.enc : plop_tab[(int)(unsigned char)*s].enc))
2325 # endif
2326 {
2327 MakePaster(&fore->w_paster, *s == '.' ? user->u_plop.buf : plop_tab[(int)(unsigned char)*s].buf, l, 0);
2328 break;
2329 }
2330 /*
2331 * if no shortcut, we construct a buffer
2332 */
2333 if ((dbuf = (char *)malloc(l)) == 0)
2334 {
2335 Msg(0, strnomem);
2336 break;
2337 }
2338 l = 0;
2339 /*
2340 * concatenate all sources into our own buffer, copy buffer is
2341 * special and is skipped if no display exists.
2342 */
2343 for (ss = s; (ch = *ss); ss++)
2344 {
2345 struct plop *pp = (ch == '.' ? &user->u_plop : &plop_tab[(int)(unsigned char)ch]);
2346 #ifdef ENCODINGS
2347 if (pp->enc != enc)
2348 {
2349 l += RecodeBuf((unsigned char *)pp->buf, pp->len, pp->enc, enc, (unsigned char *)dbuf + l);
2350 continue;
2351 }
2352 #endif
2353 bcopy(pp->buf, dbuf + l, pp->len);
2354 l += pp->len;
2355 }
2356 /*
2357 * when called with one argument we paste our buffer into the window
2358 */
2359 if (args[1] == 0)
2360 {
2361 MakePaster(&fore->w_paster, dbuf, l, 1);
2362 }
2363 else
2364 {
2365 /*
2366 * we have two arguments, the second is already in dch.
2367 * use this as destination rather than the window.
2368 */
2369 dch = args[1][0];
2370 if (dch == '.')
2371 {
2372 if (user->u_plop.buf != NULL)
2373 UserFreeCopyBuffer(user);
2374 user->u_plop.buf = dbuf;
2375 user->u_plop.len = l;
2376 #ifdef ENCODINGS
2377 user->u_plop.enc = enc;
2378 #endif
2379 }
2380 else
2381 {
2382 struct plop *pp = plop_tab + (int)(unsigned char)dch;
2383 if (pp->buf)
2384 free(pp->buf);
2385 pp->buf = dbuf;
2386 pp->len = l;
2387 #ifdef ENCODINGS
2388 pp->enc = enc;
2389 #endif
2390 }
2391 }
2392 break;
2393 }
2394 case RC_WRITEBUF:
2395 if (!user->u_plop.buf)
2396 {
2397 Msg(0, "empty buffer");
2398 break;
2399 }
2400 #ifdef ENCODINGS
2401 {
2402 struct plop oldplop;
2403
2404 oldplop = user->u_plop;
2405 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2406 {
2407 int enc, l;
2408 char *newbuf;
2409
2410 enc = FindEncoding(args[1]);
2411 if (enc == -1)
2412 {
2413 Msg(0, "%s: writebuf: unknown encoding", rc_name);
2414 break;
2415 }
2416 if (enc != oldplop.enc)
2417 {
2418 l = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)0);
2419 newbuf = malloc(l + 1);
2420 if (!newbuf)
2421 {
2422 Msg(0, strnomem);
2423 break;
2424 }
2425 user->u_plop.len = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)newbuf);
2426 user->u_plop.buf = newbuf;
2427 user->u_plop.enc = enc;
2428 }
2429 args += 2;
2430 }
2431 #endif
2432 if (args[0] && args[1])
2433 Msg(0, "%s: writebuf: too many arguments", rc_name);
2434 else
2435 WriteFile(user, args[0], DUMP_EXCHANGE);
2436 #ifdef ENCODINGS
2437 if (user->u_plop.buf != oldplop.buf)
2438 free(user->u_plop.buf);
2439 user->u_plop = oldplop;
2440 }
2441 #endif
2442 break;
2443 case RC_READBUF:
2444 #ifdef ENCODINGS
2445 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
2446 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2447 {
2448 i = FindEncoding(args[1]);
2449 if (i == -1)
2450 {
2451 Msg(0, "%s: readbuf: unknown encoding", rc_name);
2452 break;
2453 }
2454 args += 2;
2455 }
2456 #endif
2457 if (args[0] && args[1])
2458 {
2459 Msg(0, "%s: readbuf: too many arguments", rc_name);
2460 break;
2461 }
2462 if ((s = ReadFile(args[0] ? args[0] : BufferFile, &n)))
2463 {
2464 if (user->u_plop.buf)
2465 UserFreeCopyBuffer(user);
2466 user->u_plop.len = n;
2467 user->u_plop.buf = s;
2468 #ifdef ENCODINGS
2469 user->u_plop.enc = i;
2470 #endif
2471 }
2472 break;
2473 case RC_REMOVEBUF:
2474 KillBuffers();
2475 break;
2476 case RC_IGNORECASE:
2477 (void)ParseSwitch(act, &search_ic);
2478 if (msgok)
2479 Msg(0, "Will %signore case in searches", search_ic ? "" : "not ");
2480 break;
2481 #endif /* COPY_PASTE */
2482 case RC_ESCAPE:
2483 if (*argl == 0)
2484 SetEscape(user, -1, -1);
2485 else if (*argl == 2)
2486 SetEscape(user, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2487 else
2488 {
2489 Msg(0, "%s: two characters required after escape.", rc_name);
2490 break;
2491 }
2492 /* Change defescape if master user. This is because we only
2493 * have one ktab.
2494 */
2495 if (display && user != users)
2496 break;
2497 /* FALLTHROUGH */
2498 case RC_DEFESCAPE:
2499 if (*argl == 0)
2500 SetEscape(NULL, -1, -1);
2501 else if (*argl == 2)
2502 SetEscape(NULL, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2503 else
2504 {
2505 Msg(0, "%s: two characters required after defescape.", rc_name);
2506 break;
2507 }
2508 #ifdef MAPKEYS
2509 CheckEscape();
2510 #endif
2511 break;
2512 case RC_CHDIR:
2513 s = *args ? *args : home;
2514 if (chdir(s) == -1)
2515 Msg(errno, "%s", s);
2516 break;
2517 case RC_SHELL:
2518 case RC_DEFSHELL:
2519 if (ParseSaveStr(act, &ShellProg) == 0)
2520 ShellArgs[0] = ShellProg;
2521 break;
2522 case RC_HARDCOPYDIR:
2523 if (*args)
2524 (void)ParseSaveStr(act, &hardcopydir);
2525 if (msgok)
2526 Msg(0, "hardcopydir is %s\n", hardcopydir && *hardcopydir ? hardcopydir : "<cwd>");
2527 break;
2528 case RC_LOGFILE:
2529 if (*args)
2530 {
2531 if (args[1] && !(strcmp(*args, "flush")))
2532 {
2533 log_flush = atoi(args[1]);
2534 if (msgok)
2535 Msg(0, "log flush timeout set to %ds\n", log_flush);
2536 break;
2537 }
2538 if (ParseSaveStr(act, &screenlogfile) || !msgok)
2539 break;
2540 }
2541 Msg(0, "logfile is '%s'", screenlogfile);
2542 break;
2543 case RC_LOGTSTAMP:
2544 if (!*args || !strcmp(*args, "on") || !strcmp(*args, "off"))
2545 {
2546 if (ParseSwitch(act, &logtstamp_on) == 0 && msgok)
2547 Msg(0, "timestamps turned %s", logtstamp_on ? "on" : "off");
2548 }
2549 else if (!strcmp(*args, "string"))
2550 {
2551 if (args[1])
2552 {
2553 if (logtstamp_string)
2554 free(logtstamp_string);
2555 logtstamp_string = SaveStr(args[1]);
2556 }
2557 if (msgok)
2558 Msg(0, "logfile timestamp is '%s'", logtstamp_string);
2559 }
2560 else if (!strcmp(*args, "after"))
2561 {
2562 if (args[1])
2563 {
2564 logtstamp_after = atoi(args[1]);
2565 if (!msgok)
2566 break;
2567 }
2568 Msg(0, "timestamp printed after %ds\n", logtstamp_after);
2569 }
2570 else
2571 Msg(0, "usage: logtstamp [after [n]|string [str]|on|off]");
2572 break;
2573 case RC_SHELLTITLE:
2574 (void)ParseSaveStr(act, &nwin_default.aka);
2575 break;
2576 case RC_TERMCAP:
2577 case RC_TERMCAPINFO:
2578 case RC_TERMINFO:
2579 if (!rc_name || !*rc_name)
2580 Msg(0, "Sorry, too late now. Place that in your .screenrc file.");
2581 break;
2582 case RC_SLEEP:
2583 break; /* Already handled */
2584 case RC_TERM:
2585 s = NULL;
2586 if (ParseSaveStr(act, &s))
2587 break;
2588 if (strlen(s) >= 20)
2589 {
2590 Msg(0, "%s: term: argument too long ( < 20)", rc_name);
2591 free(s);
2592 break;
2593 }
2594 strcpy(screenterm, s);
2595 free(s);
2596 debug1("screenterm set to %s\n", screenterm);
2597 MakeTermcap((display == 0));
2598 debug("new termcap made\n");
2599 break;
2600 case RC_ECHO:
2601 if (!msgok && (!rc_name || strcmp(rc_name, "-X")))
2602 break;
2603 /*
2604 * user typed ^A:echo... well, echo isn't FinishRc's job,
2605 * but as he wanted to test us, we show good will
2606 */
2607 if (argc > 1 && !strcmp(*args, "-n"))
2608 {
2609 args++;
2610 argc--;
2611 }
2612 s = *args;
2613 if (argc > 1 && !strcmp(*args, "-p"))
2614 {
2615 args++;
2616 argc--;
2617 s = *args;
2618 if (s)
2619 s = MakeWinMsg(s, fore, '%');
2620 }
2621 if (s)
2622 Msg(0, "%s", s);
2623 else
2624 Msg(0, "%s: 'echo [-n] [-p] \"string\"' expected.", rc_name);
2625 break;
2626 case RC_BELL:
2627 case RC_BELL_MSG:
2628 if (*args == 0)
2629 {
2630 char buf[256];
2631 AddXChars(buf, sizeof(buf), BellString);
2632 Msg(0, "bell_msg is '%s'", buf);
2633 break;
2634 }
2635 (void)ParseSaveStr(act, &BellString);
2636 break;
2637 #ifdef COPY_PASTE
2638 case RC_BUFFERFILE:
2639 if (*args == 0)
2640 BufferFile = SaveStr(DEFAULT_BUFFERFILE);
2641 else if (ParseSaveStr(act, &BufferFile))
2642 break;
2643 if (msgok)
2644 Msg(0, "Bufferfile is now '%s'", BufferFile);
2645 break;
2646 #endif
2647 case RC_ACTIVITY:
2648 (void)ParseSaveStr(act, &ActivityString);
2649 break;
2650 #if defined(DETACH) && defined(POW_DETACH)
2651 case RC_POW_DETACH_MSG:
2652 if (*args == 0)
2653 {
2654 char buf[256];
2655 AddXChars(buf, sizeof(buf), PowDetachString);
2656 Msg(0, "pow_detach_msg is '%s'", buf);
2657 break;
2658 }
2659 (void)ParseSaveStr(act, &PowDetachString);
2660 break;
2661 #endif
2662 #if defined(UTMPOK) && defined(LOGOUTOK)
2663 case RC_LOGIN:
2664 n = fore->w_slot != (slot_t)-1;
2665 if (*args && !strcmp(*args, "always"))
2666 {
2667 fore->w_lflag = 3;
2668 if (!displays && n)
2669 SlotToggle(n);
2670 break;
2671 }
2672 if (*args && !strcmp(*args, "attached"))
2673 {
2674 fore->w_lflag = 1;
2675 if (!displays && n)
2676 SlotToggle(0);
2677 break;
2678 }
2679 if (ParseSwitch(act, &n) == 0)
2680 SlotToggle(n);
2681 break;
2682 case RC_DEFLOGIN:
2683 if (!strcmp(*args, "always"))
2684 nwin_default.lflag |= 2;
2685 else if (!strcmp(*args, "attached"))
2686 nwin_default.lflag &= ~2;
2687 else
2688 (void)ParseOnOff(act, &nwin_default.lflag);
2689 break;
2690 #endif
2691 case RC_DEFFLOW:
2692 if (args[0] && args[1] && args[1][0] == 'i')
2693 {
2694 iflag = 1;
2695 for (display = displays; display; display = display->d_next)
2696 {
2697 if (!D_flow)
2698 continue;
2699 #if defined(TERMIO) || defined(POSIX)
2700 D_NewMode.tio.c_cc[VINTR] = D_OldMode.tio.c_cc[VINTR];
2701 D_NewMode.tio.c_lflag |= ISIG;
2702 #else /* TERMIO || POSIX */
2703 D_NewMode.m_tchars.t_intrc = D_OldMode.m_tchars.t_intrc;
2704 #endif /* TERMIO || POSIX */
2705 SetTTY(D_userfd, &D_NewMode);
2706 }
2707 }
2708 if (args[0] && args[0][0] == 'a')
2709 nwin_default.flowflag = FLOW_AUTOFLAG;
2710 else
2711 (void)ParseOnOff(act, &nwin_default.flowflag);
2712 break;
2713 case RC_DEFWRAP:
2714 (void)ParseOnOff(act, &nwin_default.wrap);
2715 break;
2716 case RC_DEFC1:
2717 (void)ParseOnOff(act, &nwin_default.c1);
2718 break;
2719 #ifdef COLOR
2720 case RC_DEFBCE:
2721 (void)ParseOnOff(act, &nwin_default.bce);
2722 break;
2723 #endif
2724 case RC_DEFGR:
2725 (void)ParseOnOff(act, &nwin_default.gr);
2726 break;
2727 case RC_DEFMONITOR:
2728 if (ParseOnOff(act, &n) == 0)
2729 nwin_default.monitor = (n == 0) ? MON_OFF : MON_ON;
2730 break;
2731 case RC_DEFMOUSETRACK:
2732 if (ParseOnOff(act, &n) == 0)
2733 defmousetrack = (n == 0) ? 0 : 1000;
2734 break;
2735 case RC_MOUSETRACK:
2736 if (!args[0])
2737 {
2738 Msg(0, "Mouse tracking for this display is turned %s", D_mousetrack ? "on" : "off");
2739 }
2740 else if (ParseOnOff(act, &n) == 0)
2741 {
2742 D_mousetrack = n == 0 ? 0 : 1000;
2743 if (D_fore)
2744 MouseMode(D_fore->w_mouse);
2745 }
2746 break;
2747 case RC_DEFSILENCE:
2748 if (ParseOnOff(act, &n) == 0)
2749 nwin_default.silence = (n == 0) ? SILENCE_OFF : SILENCE_ON;
2750 break;
2751 case RC_VERBOSE:
2752 if (!*args)
2753 Msg(0, "W%s echo command when creating windows.",
2754 VerboseCreate ? "ill" : "on't");
2755 else if (ParseOnOff(act, &n) == 0)
2756 VerboseCreate = n;
2757 break;
2758 case RC_HARDSTATUS:
2759 if (display)
2760 {
2761 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
2762 RemoveStatus();
2763 }
2764 if (args[0] && strcmp(args[0], "on") && strcmp(args[0], "off"))
2765 {
2766 struct display *olddisplay = display;
2767 int old_use, new_use = -1;
2768
2769 s = args[0];
2770 if (!strncmp(s, "always", 6))
2771 s += 6;
2772 if (!strcmp(s, "lastline"))
2773 new_use = HSTATUS_LASTLINE;
2774 else if (!strcmp(s, "ignore"))
2775 new_use = HSTATUS_IGNORE;
2776 else if (!strcmp(s, "message"))
2777 new_use = HSTATUS_MESSAGE;
2778 else if (!strcmp(args[0], "string"))
2779 {
2780 if (!args[1])
2781 {
2782 char buf[256];
2783 AddXChars(buf, sizeof(buf), hstatusstring);
2784 Msg(0, "hardstatus string is '%s'", buf);
2785 break;
2786 }
2787 }
2788 else
2789 {
2790 Msg(0, "%s: usage: hardstatus [always]lastline|ignore|message|string [string]", rc_name);
2791 break;
2792 }
2793 if (new_use != -1)
2794 {
2795 hardstatusemu = new_use | (s == args[0] ? 0 : HSTATUS_ALWAYS);
2796 for (display = displays; display; display = display->d_next)
2797 {
2798 RemoveStatus();
2799 new_use = hardstatusemu & ~HSTATUS_ALWAYS;
2800 if (D_HS && s == args[0])
2801 new_use = HSTATUS_HS;
2802 ShowHStatus((char *)0);
2803 old_use = D_has_hstatus;
2804 D_has_hstatus = new_use;
2805 if ((new_use == HSTATUS_LASTLINE && old_use != HSTATUS_LASTLINE) || (new_use != HSTATUS_LASTLINE && old_use == HSTATUS_LASTLINE))
2806 ChangeScreenSize(D_width, D_height, 1);
2807 RefreshHStatus();
2808 }
2809 }
2810 if (args[1])
2811 {
2812 if (hstatusstring)
2813 free(hstatusstring);
2814 hstatusstring = SaveStr(args[1]);
2815 for (display = displays; display; display = display->d_next)
2816 RefreshHStatus();
2817 }
2818 display = olddisplay;
2819 break;
2820 }
2821 (void)ParseSwitch(act, &use_hardstatus);
2822 if (msgok)
2823 Msg(0, "messages displayed on %s", use_hardstatus ? "hardstatus line" : "window");
2824 break;
2825 case RC_CAPTION:
2826 if (strcmp(args[0], "always") == 0 || strcmp(args[0], "splitonly") == 0)
2827 {
2828 struct display *olddisplay = display;
2829
2830 captionalways = args[0][0] == 'a';
2831 for (display = displays; display; display = display->d_next)
2832 ChangeScreenSize(D_width, D_height, 1);
2833 display = olddisplay;
2834 }
2835 else if (strcmp(args[0], "string") == 0)
2836 {
2837 if (!args[1])
2838 {
2839 char buf[256];
2840 AddXChars(buf, sizeof(buf), captionstring);
2841 Msg(0, "caption string is '%s'", buf);
2842 break;
2843 }
2844 }
2845 else
2846 {
2847 Msg(0, "%s: usage: caption always|splitonly|string <string>", rc_name);
2848 break;
2849 }
2850 if (!args[1])
2851 break;
2852 if (captionstring)
2853 free(captionstring);
2854 captionstring = SaveStr(args[1]);
2855 RedisplayDisplays(0);
2856 break;
2857 case RC_CONSOLE:
2858 n = (console_window != 0);
2859 if (ParseSwitch(act, &n))
2860 break;
2861 if (TtyGrabConsole(fore->w_ptyfd, n, rc_name))
2862 break;
2863 if (n == 0)
2864 Msg(0, "%s: releasing console %s", rc_name, HostName);
2865 else if (console_window)
2866 Msg(0, "%s: stealing console %s from window %d (%s)", rc_name,
2867 HostName, console_window->w_number, console_window->w_title);
2868 else
2869 Msg(0, "%s: grabbing console %s", rc_name, HostName);
2870 console_window = n ? fore : 0;
2871 break;
2872 case RC_ALLPARTIAL:
2873 if (ParseOnOff(act, &all_norefresh))
2874 break;
2875 if (!all_norefresh && fore)
2876 Activate(-1);
2877 if (msgok)
2878 Msg(0, all_norefresh ? "No refresh on window change!\n" :
2879 "Window specific refresh\n");
2880 break;
2881 case RC_PARTIAL:
2882 (void)ParseSwitch(act, &n);
2883 fore->w_norefresh = n;
2884 break;
2885 case RC_VBELL:
2886 if (ParseSwitch(act, &visual_bell) || !msgok)
2887 break;
2888 if (visual_bell == 0)
2889 Msg(0, "switched to audible bell.");
2890 else
2891 Msg(0, "switched to visual bell.");
2892 break;
2893 case RC_VBELLWAIT:
2894 if (ParseNum1000(act, &VBellWait) == 0 && msgok)
2895 Msg(0, "vbellwait set to %.10g seconds", VBellWait/1000.);
2896 break;
2897 case RC_MSGWAIT:
2898 if (ParseNum1000(act, &MsgWait) == 0 && msgok)
2899 Msg(0, "msgwait set to %.10g seconds", MsgWait/1000.);
2900 break;
2901 case RC_MSGMINWAIT:
2902 if (ParseNum1000(act, &MsgMinWait) == 0 && msgok)
2903 Msg(0, "msgminwait set to %.10g seconds", MsgMinWait/1000.);
2904 break;
2905 case RC_SILENCEWAIT:
2906 if (ParseNum(act, &SilenceWait))
2907 break;
2908 if (SilenceWait < 1)
2909 SilenceWait = 1;
2910 for (p = windows; p; p = p->w_next)
2911 p->w_silencewait = SilenceWait;
2912 if (msgok)
2913 Msg(0, "silencewait set to %d seconds", SilenceWait);
2914 break;
2915 case RC_NUMBER:
2916 if (*args == 0)
2917 Msg(0, "This is window %d (%s).\n", fore->w_number, fore->w_title);
2918 else
2919 {
2920 int old = fore->w_number;
2921 int rel = 0, parse;
2922 if (args[0][0] == '+')
2923 rel = 1;
2924 else if (args[0][0] == '-')
2925 rel = -1;
2926 if (rel)
2927 ++act->args[0];
2928 parse = ParseNum(act, &n);
2929 if (rel)
2930 --act->args[0];
2931 if (parse)
2932 break;
2933 if (rel > 0)
2934 n += old;
2935 else if (rel < 0)
2936 n = old - n;
2937 if (n < 0 || n >= maxwin)
2938 {
2939 Msg(0, "Given window position is invalid.");
2940 return;
2941 }
2942 p = wtab[n];
2943 wtab[n] = fore;
2944 fore->w_number = n;
2945 wtab[old] = p;
2946 if (p)
2947 p->w_number = old;
2948 #ifdef MULTIUSER
2949 /* exchange the acls for these windows. */
2950 AclWinSwap(old, n);
2951 #endif
2952 #ifdef UTMPOK
2953 /* exchange the utmp-slots for these windows */
2954 if ((fore->w_slot != (slot_t) -1) && (fore->w_slot != (slot_t) 0))
2955 {
2956 RemoveUtmp(fore);
2957 SetUtmp(fore);
2958 }
2959 if (p && (p->w_slot != (slot_t) -1) && (p->w_slot != (slot_t) 0))
2960 {
2961 /* XXX: first display wins? */
2962 display = fore->w_layer.l_cvlist ? fore->w_layer.l_cvlist->c_display : 0;
2963 RemoveUtmp(p);
2964 SetUtmp(p);
2965 }
2966 #endif
2967
2968 WindowChanged(fore, 'n');
2969 WindowChanged((struct win *)0, 'w');
2970 WindowChanged((struct win *)0, 'W');
2971 WindowChanged((struct win *)0, 0);
2972 }
2973 break;
2974 case RC_SILENCE:
2975 n = fore->w_silence != 0;
2976 i = fore->w_silencewait;
2977 if (args[0] && (args[0][0] == '-' || (args[0][0] >= '0' && args[0][0] <= '9')))
2978 {
2979 if (ParseNum(act, &i))
2980 break;
2981 n = i > 0;
2982 }
2983 else if (ParseSwitch(act, &n))
2984 break;
2985 if (n)
2986 {
2987 #ifdef MULTIUSER
2988 if (display) /* we tell only this user */
2989 ACLBYTE(fore->w_lio_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2990 else
2991 for (n = 0; n < maxusercount; n++)
2992 ACLBYTE(fore->w_lio_notify, n) |= ACLBIT(n);
2993 #endif
2994 fore->w_silencewait = i;
2995 fore->w_silence = SILENCE_ON;
2996 SetTimeout(&fore->w_silenceev, fore->w_silencewait * 1000);
2997 evenq(&fore->w_silenceev);
2998
2999 if (!msgok)
3000 break;
3001 Msg(0, "The window is now being monitored for %d sec. silence.", fore->w_silencewait);
3002 }
3003 else
3004 {
3005 #ifdef MULTIUSER
3006 if (display) /* we remove only this user */
3007 ACLBYTE(fore->w_lio_notify, D_user->u_id)
3008 &= ~ACLBIT(D_user->u_id);
3009 else
3010 for (n = 0; n < maxusercount; n++)
3011 ACLBYTE(fore->w_lio_notify, n) &= ~ACLBIT(n);
3012 for (i = maxusercount - 1; i >= 0; i--)
3013 if (ACLBYTE(fore->w_lio_notify, i))
3014 break;
3015 if (i < 0)
3016 #endif
3017 {
3018 fore->w_silence = SILENCE_OFF;
3019 evdeq(&fore->w_silenceev);
3020 }
3021 if (!msgok)
3022 break;
3023 Msg(0, "The window is no longer being monitored for silence.");
3024 }
3025 break;
3026 #ifdef COPY_PASTE
3027 case RC_DEFSCROLLBACK:
3028 (void)ParseNum(act, &nwin_default.histheight);
3029 break;
3030 case RC_SCROLLBACK:
3031 if (flayer->l_layfn == &MarkLf)
3032 {
3033 Msg(0, "Cannot resize scrollback buffer in copy/scrollback mode.");
3034 break;
3035 }
3036 (void)ParseNum(act, &n);
3037 ChangeWindowSize(fore, fore->w_width, fore->w_height, n);
3038 if (msgok)
3039 Msg(0, "scrollback set to %d", fore->w_histheight);
3040 break;
3041 #endif
3042 case RC_SESSIONNAME:
3043 if (*args == 0)
3044 Msg(0, "This session is named '%s'\n", SockName);
3045 else
3046 {
3047 char buf[MAXPATHLEN];
3048
3049 s = 0;
3050 if (ParseSaveStr(act, &s))
3051 break;
3052 if (!*s || strlen(s) + (SockName - SockPath) > MAXPATHLEN - 13 || index(s, '/'))
3053 {
3054 Msg(0, "%s: bad session name '%s'\n", rc_name, s);
3055 free(s);
3056 break;
3057 }
3058 strncpy(buf, SockPath, SockName - SockPath);
3059 sprintf(buf + (SockName - SockPath), "%d.%s", (int)getpid(), s);
3060 free(s);
3061 if ((access(buf, F_OK) == 0) || (errno != ENOENT))
3062 {
3063 Msg(0, "%s: inappropriate path: '%s'.", rc_name, buf);
3064 break;
3065 }
3066 if (rename(SockPath, buf))
3067 {
3068 Msg(errno, "%s: failed to rename(%s, %s)", rc_name, SockPath, buf);
3069 break;
3070 }
3071 debug2("rename(%s, %s) done\n", SockPath, buf);
3072 strcpy(SockPath, buf);
3073 MakeNewEnv();
3074 WindowChanged((struct win *)0, 'S');
3075 }
3076 break;
3077 case RC_SETENV:
3078 if (!args[0] || !args[1])
3079 {
3080 debug1("RC_SETENV arguments missing: %s\n", args[0] ? args[0] : "");
3081 InputSetenv(args[0]);
3082 }
3083 else
3084 {
3085 xsetenv(args[0], args[1]);
3086 MakeNewEnv();
3087 }
3088 break;
3089 case RC_UNSETENV:
3090 unsetenv(*args);
3091 MakeNewEnv();
3092 break;
3093 #ifdef COPY_PASTE
3094 case RC_DEFSLOWPASTE:
3095 (void)ParseNum(act, &nwin_default.slow);
3096 break;
3097 case RC_SLOWPASTE:
3098 if (*args == 0)
3099 Msg(0, fore->w_slowpaste ?
3100 "Slowpaste in window %d is %d milliseconds." :
3101 "Slowpaste in window %d is unset.",
3102 fore->w_number, fore->w_slowpaste);
3103 else if (ParseNum(act, &fore->w_slowpaste) == 0 && msgok)
3104 Msg(0, fore->w_slowpaste ?
3105 "Slowpaste in window %d set to %d milliseconds." :
3106 "Slowpaste in window %d now unset.",
3107 fore->w_number, fore->w_slowpaste);
3108 break;
3109 case RC_MARKKEYS:
3110 if (CompileKeys(*args, *argl, mark_key_tab))
3111 {
3112 Msg(0, "%s: markkeys: syntax error.", rc_name);
3113 break;
3114 }
3115 debug1("markkeys %s\n", *args);
3116 break;
3117 # ifdef FONT
3118 case RC_PASTEFONT:
3119 if (ParseSwitch(act, &pastefont) == 0 && msgok)
3120 Msg(0, "Will %spaste font settings", pastefont ? "" : "not ");
3121 break;
3122 # endif
3123 case RC_CRLF:
3124 (void)ParseSwitch(act, &join_with_cr);
3125 break;
3126 case RC_COMPACTHIST:
3127 if (ParseSwitch(act, &compacthist) == 0 && msgok)
3128 Msg(0, "%scompacting history lines", compacthist ? "" : "not ");
3129 break;
3130 #endif
3131 #ifdef NETHACK
3132 case RC_NETHACK:
3133 (void)ParseOnOff(act, &nethackflag);
3134 break;
3135 #endif
3136 case RC_HARDCOPY_APPEND:
3137 (void)ParseOnOff(act, &hardcopy_append);
3138 break;
3139 case RC_VBELL_MSG:
3140 if (*args == 0)
3141 {
3142 char buf[256];
3143 AddXChars(buf, sizeof(buf), VisualBellString);
3144 Msg(0, "vbell_msg is '%s'", buf);
3145 break;
3146 }
3147 (void)ParseSaveStr(act, &VisualBellString);
3148 debug1(" new vbellstr '%s'\n", VisualBellString);
3149 break;
3150 case RC_DEFMODE:
3151 if (ParseBase(act, *args, &n, 8, "octal"))
3152 break;
3153 if (n < 0 || n > 0777)
3154 {
3155 Msg(0, "%s: mode: Invalid tty mode %o", rc_name, n);
3156 break;
3157 }
3158 TtyMode = n;
3159 if (msgok)
3160 Msg(0, "Ttymode set to %03o", TtyMode);
3161 break;
3162 case RC_AUTODETACH:
3163 (void)ParseOnOff(act, &auto_detach);
3164 break;
3165 case RC_STARTUP_MESSAGE:
3166 (void)ParseOnOff(act, &default_startup);
3167 break;
3168 #ifdef PASSWORD
3169 case RC_PASSWORD:
3170 if (*args)
3171 {
3172 n = (*user->u_password) ? 1 : 0;
3173 if (user->u_password != NullStr) free((char *)user->u_password);
3174 user->u_password = SaveStr(*args);
3175 if (!strcmp(user->u_password, "none"))
3176 {
3177 if (n)
3178 Msg(0, "Password checking disabled");
3179 free(user->u_password);
3180 user->u_password = NullStr;
3181 }
3182 }
3183 else
3184 {
3185 if (!fore)
3186 {
3187 Msg(0, "%s: password: window required", rc_name);
3188 break;
3189 }
3190 Input("New screen password:", 100, INP_NOECHO, pass1, display ? (char *)D_user : (char *)users, 0);
3191 }
3192 break;
3193 #endif /* PASSWORD */
3194 case RC_BIND:
3195 {
3196 struct action *ktabp = ktab;
3197 int kflag = 0;
3198
3199 for (;;)
3200 {
3201 if (argc > 2 && !strcmp(*args, "-c"))
3202 {
3203 ktabp = FindKtab(args[1], 1);
3204 if (ktabp == 0)
3205 break;
3206 args += 2;
3207 argl += 2;
3208 argc -= 2;
3209 }
3210 else if (argc > 1 && !strcmp(*args, "-k"))
3211 {
3212 kflag = 1;
3213 args++;
3214 argl++;
3215 argc--;
3216 }
3217 else
3218 break;
3219 }
3220 #ifdef MAPKEYS
3221 if (kflag)
3222 {
3223 for (n = 0; n < KMAP_KEYS; n++)
3224 if (strcmp(term[n + T_CAPS].tcname, *args) == 0)
3225 break;
3226 if (n == KMAP_KEYS)
3227 {
3228 Msg(0, "%s: bind: unknown key '%s'", rc_name, *args);
3229 break;
3230 }
3231 n += 256;
3232 }
3233 else
3234 #endif
3235 if (*argl != 1)
3236 {
3237 Msg(0, "%s: bind: character, ^x, or (octal) \\032 expected.", rc_name);
3238 break;
3239 }
3240 else
3241 n = (unsigned char)args[0][0];
3242
3243 if (args[1])
3244 {
3245 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
3246 {
3247 Msg(0, "%s: bind: unknown command '%s'", rc_name, args[1]);
3248 break;
3249 }
3250 if (CheckArgNum(i, args + 2) < 0)
3251 break;
3252 ClearAction(&ktabp[n]);
3253 SaveAction(ktabp + n, i, args + 2, argl + 2);
3254 }
3255 else
3256 ClearAction(&ktabp[n]);
3257 }
3258 break;
3259 #ifdef MAPKEYS
3260 case RC_BINDKEY:
3261 {
3262 struct action *newact;
3263 int newnr, fl = 0, kf = 0, af = 0, df = 0, mf = 0;
3264 struct display *odisp = display;
3265 int used = 0;
3266 struct kmap_ext *kme;
3267
3268 for (; *args && **args == '-'; args++, argl++)
3269 {
3270 if (strcmp(*args, "-t") == 0)
3271 fl = KMAP_NOTIMEOUT;
3272 else if (strcmp(*args, "-k") == 0)
3273 kf = 1;
3274 else if (strcmp(*args, "-a") == 0)
3275 af = 1;
3276 else if (strcmp(*args, "-d") == 0)
3277 df = 1;
3278 else if (strcmp(*args, "-m") == 0)
3279 mf = 1;
3280 else if (strcmp(*args, "--") == 0)
3281 {
3282 args++;
3283 argl++;
3284 break;
3285 }
3286 else
3287 {
3288 Msg(0, "%s: bindkey: invalid option %s", rc_name, *args);
3289 return;
3290 }
3291 }
3292 if (df && mf)
3293 {
3294 Msg(0, "%s: bindkey: -d does not work with -m", rc_name);
3295 break;
3296 }
3297 if (*args == 0)
3298 {
3299 if (mf)
3300 display_bindkey("Edit mode", mmtab);
3301 else if (df)
3302 display_bindkey("Default", dmtab);
3303 else
3304 display_bindkey("User", umtab);
3305 break;
3306 }
3307 if (kf == 0)
3308 {
3309 if (af)
3310 {
3311 Msg(0, "%s: bindkey: -a only works with -k", rc_name);
3312 break;
3313 }
3314 if (*argl == 0)
3315 {
3316 Msg(0, "%s: bindkey: empty string makes no sense", rc_name);
3317 break;
3318 }
3319 for (i = 0, kme = kmap_exts; i < kmap_extn; i++, kme++)
3320 if (kme->str == 0)
3321 {
3322 if (args[1])
3323 break;
3324 }
3325 else
3326 if (*argl == (kme->fl & ~KMAP_NOTIMEOUT) && bcmp(kme->str, *args, *argl) == 0)
3327 break;
3328 if (i == kmap_extn)
3329 {
3330 if (!args[1])
3331 {
3332 Msg(0, "%s: bindkey: keybinding not found", rc_name);
3333 break;
3334 }
3335 kmap_extn += 8;
3336 kmap_exts = (struct kmap_ext *)xrealloc((char *)kmap_exts, kmap_extn * sizeof(*kmap_exts));
3337 kme = kmap_exts + i;
3338 bzero((char *)kme, 8 * sizeof(*kmap_exts));
3339 for (; i < kmap_extn; i++, kme++)
3340 {
3341 kme->str = 0;
3342 kme->dm.nr = kme->mm.nr = kme->um.nr = RC_ILLEGAL;
3343 kme->dm.args = kme->mm.args = kme->um.args = noargs;
3344 kme->dm.argl = kme->mm.argl = kme->um.argl = 0;
3345 }
3346 i -= 8;
3347 kme -= 8;
3348 }
3349 if (df == 0 && kme->dm.nr != RC_ILLEGAL)
3350 used = 1;
3351 if (mf == 0 && kme->mm.nr != RC_ILLEGAL)
3352 used = 1;
3353 if ((df || mf) && kme->um.nr != RC_ILLEGAL)
3354 used = 1;
3355 i += KMAP_KEYS + KMAP_AKEYS;
3356 newact = df ? &kme->dm : mf ? &kme->mm : &kme->um;
3357 }
3358 else
3359 {
3360 for (i = T_CAPS; i < T_OCAPS; i++)
3361 if (strcmp(term[i].tcname, *args) == 0)
3362 break;
3363 if (i == T_OCAPS)
3364 {
3365 Msg(0, "%s: bindkey: unknown key '%s'", rc_name, *args);
3366 break;
3367 }
3368 if (af && i >= T_CURSOR && i < T_OCAPS)
3369 i -= T_CURSOR - KMAP_KEYS;
3370 else
3371 i -= T_CAPS;
3372 newact = df ? &dmtab[i] : mf ? &mmtab[i] : &umtab[i];
3373 }
3374 if (args[1])
3375 {
3376 if ((newnr = FindCommnr(args[1])) == RC_ILLEGAL)
3377 {
3378 Msg(0, "%s: bindkey: unknown command '%s'", rc_name, args[1]);
3379 break;
3380 }
3381 if (CheckArgNum(newnr, args + 2) < 0)
3382 break;
3383 ClearAction(newact);
3384 SaveAction(newact, newnr, args + 2, argl + 2);
3385 if (kf == 0 && args[1])
3386 {
3387 if (kme->str)
3388 free(kme->str);
3389 kme->str = SaveStrn(*args, *argl);
3390 kme->fl = fl | *argl;
3391 }
3392 }
3393 else
3394 ClearAction(newact);
3395 for (display = displays; display; display = display->d_next)
3396 remap(i, args[1] ? 1 : 0);
3397 if (kf == 0 && !args[1])
3398 {
3399 if (!used && kme->str)
3400 {
3401 free(kme->str);
3402 kme->str = 0;
3403 kme->fl = 0;
3404 }
3405 }
3406 display = odisp;
3407 }
3408 break;
3409 case RC_MAPTIMEOUT:
3410 if (*args)
3411 {
3412 if (ParseNum(act, &n))
3413 break;
3414 if (n < 0)
3415 {
3416 Msg(0, "%s: maptimeout: illegal time %d", rc_name, n);
3417 break;
3418 }
3419 maptimeout = n;
3420 }
3421 if (*args == 0 || msgok)
3422 Msg(0, "maptimeout is %dms", maptimeout);
3423 break;
3424 case RC_MAPNOTNEXT:
3425 D_dontmap = 1;
3426 break;
3427 case RC_MAPDEFAULT:
3428 D_mapdefault = 1;
3429 break;
3430 #endif
3431 #ifdef MULTIUSER
3432 case RC_ACLCHG:
3433 case RC_ACLADD:
3434 case RC_ADDACL:
3435 case RC_CHACL:
3436 UsersAcl(NULL, argc, args);
3437 break;
3438 case RC_ACLDEL:
3439 if (UserDel(args[0], NULL))
3440 break;
3441 if (msgok)
3442 Msg(0, "%s removed from acl database", args[0]);
3443 break;
3444 case RC_ACLGRP:
3445 /*
3446 * modify a user to gain or lose rights granted to a group.
3447 * This group is actually a normal user whose rights were defined
3448 * with chacl in the usual way.
3449 */
3450 if (args[1])
3451 {
3452 if (strcmp(args[1], "none")) /* link a user to another user */
3453 {
3454 if (AclLinkUser(args[0], args[1]))
3455 break;
3456 if (msgok)
3457 Msg(0, "User %s joined acl-group %s", args[0], args[1]);
3458 }
3459 else /* remove all groups from user */
3460 {
3461 struct acluser *u;
3462 struct aclusergroup *g;
3463
3464 if (!(u = *FindUserPtr(args[0])))
3465 break;
3466 while ((g = u->u_group))
3467 {
3468 u->u_group = g->next;
3469 free((char *)g);
3470 }
3471 }
3472 }
3473 else /* show all groups of user */
3474 {
3475 char buf[256], *p = buf;
3476 int ngroups = 0;
3477 struct acluser *u;
3478 struct aclusergroup *g;
3479
3480 if (!(u = *FindUserPtr(args[0])))
3481 {
3482 if (msgok)
3483 Msg(0, "User %s does not exist.", args[0]);
3484 break;
3485 }
3486 g = u->u_group;
3487 while (g)
3488 {
3489 ngroups++;
3490 sprintf(p, "%s ", g->u->u_name);
3491 p += strlen(p);
3492 if (p > buf+200)
3493 break;
3494 g = g->next;
3495 }
3496 if (ngroups)
3497 *(--p) = '\0';
3498 Msg(0, "%s's group%s: %s.", args[0], (ngroups == 1) ? "" : "s",
3499 (ngroups == 0) ? "none" : buf);
3500 }
3501 break;
3502 case RC_ACLUMASK:
3503 case RC_UMASK:
3504 while ((s = *args++))
3505 {
3506 char *err = 0;
3507
3508 if (AclUmask(display ? D_user : users, s, &err))
3509 Msg(0, "umask: %s\n", err);
3510 }
3511 break;
3512 case RC_MULTIUSER:
3513 if (ParseOnOff(act, &n))
3514 break;
3515 multi = n ? "" : 0;
3516 chsock();
3517 if (msgok)
3518 Msg(0, "Multiuser mode %s", multi ? "enabled" : "disabled");
3519 break;
3520 #endif /* MULTIUSER */
3521 #ifdef PSEUDOS
3522 case RC_EXEC:
3523 winexec(args);
3524 break;
3525 #endif
3526 #ifdef MULTI
3527 case RC_NONBLOCK:
3528 i = D_nonblock >= 0;
3529 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3530 {
3531 if (ParseNum1000(act, &i))
3532 break;
3533 }
3534 else if (!ParseSwitch(act, &i))
3535 i = i == 0 ? -1 : 1000;
3536 else
3537 break;
3538 if (msgok && i == -1)
3539 Msg(0, "display set to blocking mode");
3540 else if (msgok && i == 0)
3541 Msg(0, "display set to nonblocking mode, no timeout");
3542 else if (msgok)
3543 Msg(0, "display set to nonblocking mode, %.10gs timeout", i/1000.);
3544 D_nonblock = i;
3545 if (D_nonblock <= 0)
3546 evdeq(&D_blockedev);
3547 break;
3548 case RC_DEFNONBLOCK:
3549 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3550 {
3551 if (ParseNum1000(act, &defnonblock))
3552 break;
3553 }
3554 else if (!ParseOnOff(act, &defnonblock))
3555 defnonblock = defnonblock == 0 ? -1 : 1000;
3556 else
3557 break;
3558 if (display && *rc_name)
3559 {
3560 D_nonblock = defnonblock;
3561 if (D_nonblock <= 0)
3562 evdeq(&D_blockedev);
3563 }
3564 break;
3565 #endif
3566 case RC_GR:
3567 #ifdef ENCODINGS
3568 if (fore->w_gr == 2)
3569 fore->w_gr = 0;
3570 #endif
3571 if (ParseSwitch(act, &fore->w_gr) == 0 && msgok)
3572 Msg(0, "Will %suse GR", fore->w_gr ? "" : "not ");
3573 #ifdef ENCODINGS
3574 if (fore->w_gr == 0 && fore->w_FontE)
3575 fore->w_gr = 2;
3576 #endif
3577 break;
3578 case RC_C1:
3579 if (ParseSwitch(act, &fore->w_c1) == 0 && msgok)
3580 Msg(0, "Will %suse C1", fore->w_c1 ? "" : "not ");
3581 break;
3582 #ifdef COLOR
3583 case RC_BCE:
3584 if (ParseSwitch(act, &fore->w_bce) == 0 && msgok)
3585 Msg(0, "Will %serase with background color", fore->w_bce ? "" : "not ");
3586 break;
3587 #endif
3588 #ifdef ENCODINGS
3589 case RC_KANJI:
3590 case RC_ENCODING:
3591 #ifdef UTF8
3592 if (*args && !strcmp(args[0], "-d"))
3593 {
3594 if (!args[1])
3595 Msg(0, "encodings directory is %s", screenencodings ? screenencodings : "<unset>");
3596 else
3597 {
3598 free(screenencodings);
3599 screenencodings = SaveStr(args[1]);
3600 }
3601 break;
3602 }
3603 if (*args && !strcmp(args[0], "-l"))
3604 {
3605 if (!args[1])
3606 Msg(0, "encoding: -l: argument required");
3607 else if (LoadFontTranslation(-1, args[1]))
3608 Msg(0, "encoding: could not load utf8 encoding file");
3609 else if (msgok)
3610 Msg(0, "encoding: utf8 encoding file loaded");
3611 break;
3612 }
3613 #else
3614 if (*args && (!strcmp(args[0], "-l") || !strcmp(args[0], "-d")))
3615 {
3616 if (msgok)
3617 Msg(0, "encoding: screen is not compiled for UTF-8.");
3618 break;
3619 }
3620 #endif
3621 for (i = 0; i < 2; i++)
3622 {
3623 if (args[i] == 0)
3624 break;
3625 if (!strcmp(args[i], "."))
3626 continue;
3627 n = FindEncoding(args[i]);
3628 if (n == -1)
3629 {
3630 Msg(0, "encoding: unknown encoding '%s'", args[i]);
3631 break;
3632 }
3633 if (i == 0 && fore)
3634 {
3635 WinSwitchEncoding(fore, n);
3636 ResetCharsets(fore);
3637 }
3638 else if (i && display)
3639 D_encoding = n;
3640 }
3641 break;
3642 case RC_DEFKANJI:
3643 case RC_DEFENCODING:
3644 n = FindEncoding(*args);
3645 if (n == -1)
3646 {
3647 Msg(0, "defencoding: unknown encoding '%s'", *args);
3648 break;
3649 }
3650 nwin_default.encoding = n;
3651 break;
3652 #endif
3653
3654 #ifdef UTF8
3655 case RC_DEFUTF8:
3656 n = nwin_default.encoding == UTF8;
3657 if (ParseSwitch(act, &n) == 0)
3658 {
3659 nwin_default.encoding = n ? UTF8 : 0;
3660 if (msgok)
3661 Msg(0, "Will %suse UTF-8 encoding for new windows", n ? "" : "not ");
3662 }
3663 break;
3664 case RC_UTF8:
3665 for (i = 0; i < 2; i++)
3666 {
3667 if (i && args[i] == 0)
3668 break;
3669 if (args[i] == 0)
3670 n = fore->w_encoding != UTF8;
3671 else if (strcmp(args[i], "off") == 0)
3672 n = 0;
3673 else if (strcmp(args[i], "on") == 0)
3674 n = 1;
3675 else
3676 {
3677 Msg(0, "utf8: illegal argument (%s)", args[i]);
3678 break;
3679 }
3680 if (i == 0)
3681 {
3682 WinSwitchEncoding(fore, n ? UTF8 : 0);
3683 if (msgok)
3684 Msg(0, "Will %suse UTF-8 encoding", n ? "" : "not ");
3685 }
3686 else if (display)
3687 D_encoding = n ? UTF8 : 0;
3688 if (args[i] == 0)
3689 break;
3690 }
3691 break;
3692 #endif
3693
3694 case RC_PRINTCMD:
3695 if (*args)
3696 {
3697 if (printcmd)
3698 free(printcmd);
3699 printcmd = 0;
3700 if (**args)
3701 printcmd = SaveStr(*args);
3702 }
3703 if (*args == 0 || msgok)
3704 {
3705 if (printcmd)
3706 Msg(0, "using '%s' as print command", printcmd);
3707 else
3708 Msg(0, "using termcap entries for printing");
3709 break;
3710 }
3711 break;
3712
3713 case RC_DIGRAPH:
3714 if (argl && argl[0] > 0 && argl[1] > 0)
3715 {
3716 if (argl[0] != 2)
3717 {
3718 Msg(0, "Two characters expected to define a digraph");
3719 break;
3720 }
3721 i = digraph_find(args[0]);
3722 digraphs[i].d[0] = args[0][0];
3723 digraphs[i].d[1] = args[0][1];
3724 if (!parse_input_int(args[1], argl[1], &digraphs[i].value))
3725 {
3726 if (!(digraphs[i].value = atoi(args[1])))
3727 {
3728 if (!args[1][1])
3729 digraphs[i].value = (int)args[1][0];
3730 #ifdef UTF8
3731 else
3732 {
3733 int t;
3734 unsigned char *s = args[1];
3735 digraphs[i].value = 0;
3736 while (*s)
3737 {
3738 t = FromUtf8(*s++, &digraphs[i].value);
3739 if (t == -1)
3740 continue;
3741 if (t == -2)
3742 digraphs[i].value = 0;
3743 else
3744 digraphs[i].value = t;
3745 break;
3746 }
3747 }
3748 #endif
3749 }
3750 }
3751 break;
3752 }
3753 Input("Enter digraph: ", 10, INP_EVERY, digraph_fn, NULL, 0);
3754 if (*args && **args)
3755 {
3756 s = *args;
3757 n = strlen(s);
3758 LayProcess(&s, &n);
3759 }
3760 break;
3761
3762 case RC_DEFHSTATUS:
3763 if (*args == 0)
3764 {
3765 char buf[256];
3766 *buf = 0;
3767 if (nwin_default.hstatus)
3768 AddXChars(buf, sizeof(buf), nwin_default.hstatus);
3769 Msg(0, "default hstatus is '%s'", buf);
3770 break;
3771 }
3772 (void)ParseSaveStr(act, &nwin_default.hstatus);
3773 if (*nwin_default.hstatus == 0)
3774 {
3775 free(nwin_default.hstatus);
3776 nwin_default.hstatus = 0;
3777 }
3778 break;
3779 case RC_HSTATUS:
3780 (void)ParseSaveStr(act, &fore->w_hstatus);
3781 if (*fore->w_hstatus == 0)
3782 {
3783 free(fore->w_hstatus);
3784 fore->w_hstatus = 0;
3785 }
3786 WindowChanged(fore, 'h');
3787 break;
3788
3789 #ifdef FONT
3790 case RC_DEFCHARSET:
3791 case RC_CHARSET:
3792 if (*args == 0)
3793 {
3794 char buf[256];
3795 *buf = 0;
3796 if (nwin_default.charset)
3797 AddXChars(buf, sizeof(buf), nwin_default.charset);
3798 Msg(0, "default charset is '%s'", buf);
3799 break;
3800 }
3801 n = strlen(*args);
3802 if (n == 0 || n > 6)
3803 {
3804 Msg(0, "%s: %s: string has illegal size.", rc_name, comms[nr].name);
3805 break;
3806 }
3807 if (n > 4 && (
3808 ((args[0][4] < '0' || args[0][4] > '3') && args[0][4] != '.') ||
3809 ((args[0][5] < '0' || args[0][5] > '3') && args[0][5] && args[0][5] != '.')))
3810 {
3811 Msg(0, "%s: %s: illegal mapping number.", rc_name, comms[nr].name);
3812 break;
3813 }
3814 if (nr == RC_CHARSET)
3815 {
3816 SetCharsets(fore, *args);
3817 break;
3818 }
3819 if (nwin_default.charset)
3820 free(nwin_default.charset);
3821 nwin_default.charset = SaveStr(*args);
3822 break;
3823 #endif
3824 #ifdef COLOR
3825 case RC_ATTRCOLOR:
3826 s = args[0];
3827 if (*s >= '0' && *s <= '9')
3828 i = *s - '0';
3829 else
3830 for (i = 0; i < 8; i++)
3831 if (*s == "dubrsBiI"[i])
3832 break;
3833 s++;
3834 nr = 0;
3835 if (*s && s[1] && !s[2])
3836 {
3837 if (*s == 'd' && s[1] == 'd')
3838 nr = 3;
3839 else if (*s == '.' && s[1] == 'd')
3840 nr = 2;
3841 else if (*s == 'd' && s[1] == '.')
3842 nr = 1;
3843 else if (*s != '.' || s[1] != '.')
3844 s--;
3845 s += 2;
3846 }
3847 if (*s || i < 0 || i >= 8)
3848 {
3849 Msg(0, "%s: attrcolor: unknown attribute '%s'.", rc_name, args[0]);
3850 break;
3851 }
3852 n = 0;
3853 if (args[1])
3854 n = ParseAttrColor(args[1], args[2], 1);
3855 if (n == -1)
3856 break;
3857 attr2color[i][nr] = n;
3858 n = 0;
3859 for (i = 0; i < 8; i++)
3860 if (attr2color[i][0] || attr2color[i][1] || attr2color[i][2] || attr2color[i][3])
3861 n |= 1 << i;
3862 nattr2color = n;
3863 break;
3864 #endif
3865 case RC_RENDITION:
3866 i = -1;
3867 if (strcmp(args[0], "bell") == 0)
3868 {
3869 i = REND_BELL;
3870 }
3871 else if (strcmp(args[0], "monitor") == 0)
3872 {
3873 i = REND_MONITOR;
3874 }
3875 else if (strcmp(args[0], "so") != 0)
3876 {
3877 Msg(0, "Invalid option '%s' for rendition", args[0]);
3878 break;
3879 }
3880
3881 ++args;
3882 ++argl;
3883
3884 if (i != -1)
3885 {
3886 renditions[i] = ParseAttrColor(args[0], args[1], 1);
3887 WindowChanged((struct win *)0, 'w');
3888 WindowChanged((struct win *)0, 'W');
3889 WindowChanged((struct win *)0, 0);
3890 break;
3891 }
3892
3893 /* We are here, means we want to set the sorendition. */
3894 /* FALLTHROUGH*/
3895 case RC_SORENDITION:
3896 i = 0;
3897 if (*args)
3898 {
3899 i = ParseAttrColor(*args, args[1], 1);
3900 if (i == -1)
3901 break;
3902 ApplyAttrColor(i, &mchar_so);
3903 WindowChanged((struct win *)0, 0);
3904 debug2("--> %x %x\n", mchar_so.attr, mchar_so.color);
3905 }
3906 if (msgok)
3907 #ifdef COLOR
3908 Msg(0, "Standout attributes 0x%02x color 0x%02x", (unsigned char)mchar_so.attr, 0x99 ^ (unsigned char)mchar_so.color);
3909 #else
3910 Msg(0, "Standout attributes 0x%02x ", (unsigned char)mchar_so.attr);
3911 #endif
3912 break;
3913
3914 case RC_SOURCE:
3915 do_source(*args);
3916 break;
3917
3918 #ifdef MULTIUSER
3919 case RC_SU:
3920 s = NULL;
3921 if (!*args)
3922 {
3923 Msg(0, "%s:%s screen login", HostName, SockPath);
3924 InputSu(D_fore, &D_user, NULL);
3925 }
3926 else if (!args[1])
3927 InputSu(D_fore, &D_user, args[0]);
3928 else if (!args[2])
3929 s = DoSu(&D_user, args[0], args[1], "\377");
3930 else
3931 s = DoSu(&D_user, args[0], args[1], args[2]);
3932 if (s)
3933 Msg(0, "%s", s);
3934 break;
3935 #endif /* MULTIUSER */
3936 case RC_SPLIT:
3937 s = args[0];
3938 if (s && !strcmp(s, "-v"))
3939 AddCanvas(SLICE_HORI);
3940 else
3941 AddCanvas(SLICE_VERT);
3942 Activate(-1);
3943 break;
3944 case RC_REMOVE:
3945 RemCanvas();
3946 Activate(-1);
3947 break;
3948 case RC_ONLY:
3949 OneCanvas();
3950 Activate(-1);
3951 break;
3952 case RC_FIT:
3953 D_forecv->c_xoff = D_forecv->c_xs;
3954 D_forecv->c_yoff = D_forecv->c_ys;
3955 RethinkViewportOffsets(D_forecv);
3956 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
3957 flayer = D_forecv->c_layer;
3958 LaySetCursor();
3959 break;
3960 case RC_FOCUS:
3961 {
3962 struct canvas *cv = 0;
3963 if (!*args || !strcmp(*args, "next"))
3964 cv = D_forecv->c_next ? D_forecv->c_next : D_cvlist;
3965 else if (!strcmp(*args, "prev"))
3966 {
3967 for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next)
3968 ;
3969 }
3970 else if (!strcmp(*args, "top"))
3971 cv = D_cvlist;
3972 else if (!strcmp(*args, "bottom"))
3973 {
3974 for (cv = D_cvlist; cv->c_next; cv = cv->c_next)
3975 ;
3976 }
3977 else if (!strcmp(*args, "up"))
3978 cv = FindCanvas(D_forecv->c_xs, D_forecv->c_ys - 1);
3979 else if (!strcmp(*args, "down"))
3980 cv = FindCanvas(D_forecv->c_xs, D_forecv->c_ye + 2);
3981 else if (!strcmp(*args, "left"))
3982 cv = FindCanvas(D_forecv->c_xs - 1, D_forecv->c_ys);
3983 else if (!strcmp(*args, "right"))
3984 cv = FindCanvas(D_forecv->c_xe + 1, D_forecv->c_ys);
3985 else
3986 {
3987 Msg(0, "%s: usage: focus [next|prev|up|down|left|right|top|bottom]", rc_name);
3988 break;
3989 }
3990 SetForeCanvas(display, cv);
3991 }
3992 break;
3993 case RC_RESIZE:
3994 i = 0;
3995 if (D_forecv->c_slorient == SLICE_UNKN)
3996 {
3997 Msg(0, "resize: need more than one region");
3998 break;
3999 }
4000 for (; *args; args++)
4001 {
4002 if (!strcmp(*args, "-h"))
4003 i |= RESIZE_FLAG_H;
4004 else if (!strcmp(*args, "-v"))
4005 i |= RESIZE_FLAG_V;
4006 else if (!strcmp(*args, "-b"))
4007 i |= RESIZE_FLAG_H | RESIZE_FLAG_V;
4008 else if (!strcmp(*args, "-p"))
4009 i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
4010 else if (!strcmp(*args, "-l"))
4011 i |= RESIZE_FLAG_L;
4012 else
4013 break;
4014 }
4015 if (*args && args[1])
4016 {
4017 Msg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name);
4018 break;
4019 }
4020 if (*args)
4021 ResizeRegions(*args, i);
4022 else
4023 Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i);
4024 break;
4025 case RC_SETSID:
4026 (void)ParseSwitch(act, &separate_sids);
4027 break;
4028 case RC_EVAL:
4029 args = SaveArgs(args);
4030 for (i = 0; args[i]; i++)
4031 {
4032 if (args[i][0])
4033 Colonfin(args[i], strlen(args[i]), (char *)0);
4034 free(args[i]);
4035 }
4036 free(args);
4037 break;
4038 case RC_ALTSCREEN:
4039 (void)ParseSwitch(act, &use_altscreen);
4040 if (msgok)
4041 Msg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not ");
4042 break;
4043 case RC_MAXWIN:
4044 if (ParseNum(act, &n))
4045 break;
4046 if (n < 1)
4047 Msg(0, "illegal maxwin number specified");
4048 else if (n > maxwin)
4049 Msg(0, "may only decrease maxwin number");
4050 else
4051 maxwin = n;
4052 break;
4053 case RC_BACKTICK:
4054 if (ParseBase(act, *args, &n, 10, "decimal"))
4055 break;
4056 if (!args[1])
4057 setbacktick(n, 0, 0, (char **)0);
4058 else
4059 {
4060 int lifespan, tick;
4061 if (argc < 4)
4062 {
4063 Msg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name);
4064 break;
4065 }
4066 if (ParseBase(act, args[1], &lifespan, 10, "decimal"))
4067 break;
4068 if (ParseBase(act, args[2], &tick, 10, "decimal"))
4069 break;
4070 setbacktick(n, lifespan, tick, SaveArgs(args + 3));
4071 }
4072 WindowChanged(0, '`');
4073 break;
4074 case RC_BLANKER:
4075 #ifdef BLANKER_PRG
4076 if (blankerprg)
4077 {
4078 RunBlanker(blankerprg);
4079 break;
4080 }
4081 #endif
4082 ClearAll();
4083 CursorVisibility(-1);
4084 D_blocked = 4;
4085 break;
4086 #ifdef BLANKER_PRG
4087 case RC_BLANKERPRG:
4088 if (blankerprg)
4089 {
4090 char **pp;
4091 for (pp = blankerprg; *pp; pp++)
4092 free(*pp);
4093 free(blankerprg);
4094 blankerprg = 0;
4095 }
4096 if (args[0][0])
4097 blankerprg = SaveArgs(args);
4098 break;
4099 #endif
4100 case RC_IDLE:
4101 if (*args)
4102 {
4103 struct display *olddisplay = display;
4104 if (!strcmp(*args, "off"))
4105 idletimo = 0;
4106 else if (args[0][0])
4107 idletimo = atoi(*args) * 1000;
4108 if (argc > 1)
4109 {
4110 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
4111 {
4112 Msg(0, "%s: idle: unknown command '%s'", rc_name, args[1]);
4113 break;
4114 }
4115 if (CheckArgNum(i, args + 2) < 0)
4116 break;
4117 ClearAction(&idleaction);
4118 SaveAction(&idleaction, i, args + 2, argl + 2);
4119 }
4120 for (display = displays; display; display = display->d_next)
4121 ResetIdle();
4122 display = olddisplay;
4123 }
4124 if (msgok)
4125 {
4126 if (idletimo)
4127 Msg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name);
4128 else
4129 Msg(0, "idle off");
4130 }
4131 break;
4132 case RC_FOCUSMINSIZE:
4133 for (i = 0; i < 2 && args[i]; i++)
4134 {
4135 if (!strcmp(args[i], "max") || !strcmp(args[i], "_"))
4136 n = -1;
4137 else
4138 n = atoi(args[i]);
4139 if (i == 0)
4140 focusminwidth = n;
4141 else
4142 focusminheight = n;
4143 }
4144 if (msgok)
4145 {
4146 char b[2][20];
4147 for (i = 0; i < 2; i++)
4148 {
4149 n = i == 0 ? focusminwidth : focusminheight;
4150 if (n == -1)
4151 strcpy(b[i], "max");
4152 else
4153 sprintf(b[i], "%d", n);
4154 }
4155 Msg(0, "focus min size is %s %s\n", b[0], b[1]);
4156 }
4157 break;
4158 case RC_GROUP:
4159 if (*args)
4160 {
4161 fore->w_group = 0;
4162 if (args[0][0])
4163 {
4164 fore->w_group = WindowByName(*args);
4165 if (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)
4166 fore->w_group = 0;
4167 }
4168 WindowChanged((struct win *)0, 'w');
4169 WindowChanged((struct win *)0, 'W');
4170 WindowChanged((struct win *)0, 0);
4171 }
4172 if (msgok)
4173 {
4174 if (fore->w_group)
4175 Msg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title);
4176 else
4177 Msg(0, "window belongs to no group");
4178 }
4179 break;
4180 case RC_LAYOUT:
4181 if (!strcmp(args[0], "title"))
4182 {
4183 if (!D_layout)
4184 {
4185 Msg(0, "not on a layout");
4186 break;
4187 }
4188 if (!args[1])
4189 {
4190 Msg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title);
4191 break;
4192 }
4193 free(D_layout->lay_title);
4194 D_layout->lay_title= SaveStr(args[1]);
4195 }
4196 else if (!strcmp(args[0], "number"))
4197 {
4198 int old;
4199 struct layout *lay;
4200 if (!D_layout)
4201 {
4202 Msg(0, "not on a layout");
4203 break;
4204 }
4205 if (!args[1])
4206 {
4207 Msg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title);
4208 break;
4209 }
4210 old = D_layout->lay_number;
4211 n = atoi(args[1]);
4212 if (n < 0 || n >= MAXLAY)
4213 break;
4214 lay = laytab[n];
4215 laytab[n] = D_layout;
4216 D_layout->lay_number = n;
4217 laytab[old] = lay;
4218 if (lay)
4219 lay->lay_number = old;
4220 break;
4221 }
4222 else if (!strcmp(args[0], "autosave"))
4223 {
4224 if (!D_layout)
4225 {
4226 Msg(0, "not on a layout");
4227 break;
4228 }
4229 if (args[1])
4230 {
4231 if (!strcmp(args[1], "on"))
4232 D_layout->lay_autosave = 1;
4233 else if (!strcmp(args[1], "off"))
4234 D_layout->lay_autosave = 0;
4235 else
4236 {
4237 Msg(0, "invalid argument. Give 'on' or 'off");
4238 break;
4239 }
4240 }
4241 if (msgok)
4242 Msg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off");
4243 }
4244 else if (!strcmp(args[0], "new"))
4245 {
4246 char *t = args[1];
4247 n = 0;
4248 if (t)
4249 {
4250 while (*t >= '0' && *t <= '9')
4251 t++;
4252 if (t != args[1] && (!*t || *t == ':'))
4253 {
4254 n = atoi(args[1]);
4255 if (*t)
4256 t++;
4257 }
4258 else
4259 t = args[1];
4260 }
4261 if (!t || !*t)
4262 t = "layout";
4263 NewLayout(t, n);
4264 Activate(-1);
4265 }
4266 else if (!strcmp(args[0], "save"))
4267 {
4268 if (!args[1])
4269 {
4270 Msg(0, "usage: layout save <name>");
4271 break;
4272 }
4273 SaveLayout(args[1], &D_canvas);
4274 }
4275 else if (!strcmp(args[0], "select"))
4276 {
4277 if (!args[1])
4278 {
4279 Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0);
4280 break;
4281 }
4282 SelectLayoutFin(args[1], strlen(args[1]), (char *)0);
4283 }
4284 else if (!strcmp(args[0], "next"))
4285 {
4286 struct layout *lay = D_layout;
4287 if (lay)
4288 lay = lay->lay_next ? lay->lay_next : layouts;
4289 else
4290 lay = layouts;
4291 if (!lay)
4292 {
4293 Msg(0, "no layout defined");
4294 break;
4295 }
4296 if (lay == D_layout)
4297 break;
4298 LoadLayout(lay, &D_canvas);
4299 Activate(-1);
4300 }
4301 else if (!strcmp(args[0], "prev"))
4302 {
4303 struct layout *lay = D_layout;
4304 if (lay)
4305 {
4306 for (lay = layouts; lay->lay_next && lay->lay_next != D_layout; lay = lay->lay_next)
4307 ;
4308 }
4309 else
4310 lay = layouts;
4311 if (!lay)
4312 {
4313 Msg(0, "no layout defined");
4314 break;
4315 }
4316 if (lay == D_layout)
4317 break;
4318 LoadLayout(lay, &D_canvas);
4319 Activate(-1);
4320 }
4321 else if (!strcmp(args[0], "attach"))
4322 {
4323 if (!args[1])
4324 {
4325 if (!layout_attach)
4326 Msg(0, "no attach layout set");
4327 else if (layout_attach == &layout_last_marker)
4328 Msg(0, "will attach to last layout");
4329 else
4330 Msg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title);
4331 break;
4332 }
4333 if (!strcmp(args[1], ":last"))
4334 layout_attach = &layout_last_marker;
4335 else if (!args[1][0])
4336 layout_attach = 0;
4337 else
4338 {
4339 struct layout *lay;
4340 lay = FindLayout(args[1]);
4341 if (!lay)
4342 {
4343 Msg(0, "unknown layout '%s'", args[1]);
4344 break;
4345 }
4346 layout_attach = lay;
4347 }
4348 }
4349 else if (!strcmp(args[0], "show"))
4350 {
4351 ShowLayouts(-1);
4352 }
4353 else if (!strcmp(args[0], "remove"))
4354 {
4355 struct layout *lay = display ? D_layout : layouts;
4356 if (args[1])
4357 {
4358 lay = layouts ? FindLayout(args[1]) : (struct layout *)0;
4359 if (!lay)
4360 {
4361 Msg(0, "unknown layout '%s'", args[1]);
4362 break;
4363 }
4364 }
4365 if (lay)
4366 RemoveLayout(lay);
4367 }
4368 else
4369 Msg(0, "unknown layout subcommand");
4370 break;
4371 #ifdef DW_CHARS
4372 case RC_CJKWIDTH:
4373 if(ParseSwitch(act, &cjkwidth) == 0)
4374 {
4375 if(msgok)
4376 Msg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half");
4377 }
4378 break;
4379 #endif
4380 default:
4381 #ifdef HAVE_BRAILLE
4382 /* key == -2: input from braille keybord, msgok always 0 */
4383 DoBrailleAction(act, key == -2 ? 0 : msgok);
4384 #endif
4385 break;
4386 }
4387 if (display != odisplay)
4388 {
4389 for (display = displays; display; display = display->d_next)
4390 if (display == odisplay)
4391 break;
4392 }
4393 }
4394
4395 void
4396 DoCommand(argv, argl)
4397 char **argv;
4398 int *argl;
4399 {
4400 struct action act;
4401
4402 if ((act.nr = FindCommnr(*argv)) == RC_ILLEGAL)
4403 {
4404 Msg(0, "%s: unknown command '%s'", rc_name, *argv);
4405 return;
4406 }
4407 act.args = argv + 1;
4408 act.argl = argl + 1;
4409 DoAction(&act, -1);
4410 }
4411
4412 static void
4413 SaveAction(act, nr, args, argl)
4414 struct action *act;
4415 int nr;
4416 char **args;
4417 int *argl;
4418 {
4419 register int argc = 0;
4420 char **pp;
4421 int *lp;
4422
4423 if (args)
4424 while (args[argc])
4425 argc++;
4426 if (argc == 0)
4427 {
4428 act->nr = nr;
4429 act->args = noargs;
4430 act->argl = 0;
4431 return;
4432 }
4433 if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4434 Panic(0, strnomem);
4435 if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int *))) == 0)
4436 Panic(0, strnomem);
4437 act->nr = nr;
4438 act->args = pp;
4439 act->argl = lp;
4440 while (argc--)
4441 {
4442 *lp = argl ? *argl++ : (int)strlen(*args);
4443 *pp++ = SaveStrn(*args++, *lp++);
4444 }
4445 *pp = 0;
4446 }
4447
4448 static char **
4449 SaveArgs(args)
4450 char **args;
4451 {
4452 register char **ap, **pp;
4453 register int argc = 0;
4454
4455 while (args[argc])
4456 argc++;
4457 if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4458 Panic(0, strnomem);
4459 while (argc--)
4460 *pp++ = SaveStr(*args++);
4461 *pp = 0;
4462 return ap;
4463 }
4464
4465
4466 /*
4467 * buf is split into argument vector args.
4468 * leading whitespace is removed.
4469 * @!| abbreviations are expanded.
4470 * the end of buffer is recognized by '\0' or an un-escaped '#'.
4471 * " and ' are interpreted.
4472 *
4473 * argc is returned.
4474 */
4475 int
4476 Parse(buf, bufl, args, argl)
4477 char *buf, **args;
4478 int bufl, *argl;
4479 {
4480 register char *p = buf, **ap = args, *pp;
4481 register int delim, argc;
4482 int *lp = argl;
4483
4484 debug2("Parse %d %s\n", bufl, buf);
4485 argc = 0;
4486 pp = buf;
4487 delim = 0;
4488 for (;;)
4489 {
4490 *lp = 0;
4491 while (*p && (*p == ' ' || *p == '\t'))
4492 ++p;
4493 #ifdef PSEUDOS
4494 if (argc == 0 && *p == '!')
4495 {
4496 *ap++ = "exec";
4497 *lp++ = 4;
4498 p++;
4499 argc++;
4500 continue;
4501 }
4502 #endif
4503 if (*p == '\0' || *p == '#' || *p == '\n')
4504 {
4505 *p = '\0';
4506 for (delim = 0; delim < argc; delim++)
4507 debug1("-- %s\n", args[delim]);
4508 args[argc] = 0;
4509 return argc;
4510 }
4511 if (++argc >= MAXARGS)
4512 {
4513 Msg(0, "%s: too many tokens.", rc_name);
4514 return 0;
4515 }
4516 *ap++ = pp;
4517
4518 debug1("- new arg %s\n", p);
4519 while (*p)
4520 {
4521 if (*p == delim)
4522 delim = 0;
4523 else if (delim != '\'' && *p == '\\' && (p[1] == 'n' || p[1] == 'r' || p[1] == 't' || p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7')))
4524 {
4525 p++;
4526 if (*p >= '0' && *p <= '7')
4527 {
4528 *pp = *p - '0';
4529 if (p[1] >= '0' && p[1] <= '7')
4530 {
4531 p++;
4532 *pp = (*pp << 3) | (*p - '0');
4533 if (p[1] >= '0' && p[1] <= '7')
4534 {
4535 p++;
4536 *pp = (*pp << 3) | (*p - '0');
4537 }
4538 }
4539 pp++;
4540 }
4541 else
4542 {
4543 switch (*p)
4544 {
4545 case 'n': *pp = '\n'; break;
4546 case 'r': *pp = '\r'; break;
4547 case 't': *pp = '\t'; break;
4548 default: *pp = *p; break;
4549 }
4550 pp++;
4551 }
4552 }
4553 else if (delim != '\'' && *p == '$' && (p[1] == '{' || p[1] == ':' || (p[1] >= 'a' && p[1] <= 'z') || (p[1] >= 'A' && p[1] <= 'Z') || (p[1] >= '0' && p[1] <= '9') || p[1] == '_'))
4554
4555 {
4556 char *ps, *pe, op, *v, xbuf[11];
4557 int vl;
4558
4559 ps = ++p;
4560 debug1("- var %s\n", ps);
4561 p++;
4562 while (*p)
4563 {
4564 if (*ps == '{' && *p == '}')
4565 break;
4566 if (*ps == ':' && *p == ':')
4567 break;
4568 if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_')
4569 break;
4570 p++;
4571 }
4572 pe = p;
4573 if (*ps == '{' || *ps == ':')
4574 {
4575 if (!*p)
4576 {
4577 Msg(0, "%s: bad variable name.", rc_name);
4578 return 0;
4579 }
4580 p++;
4581 }
4582 op = *pe;
4583 *pe = 0;
4584 debug1("- var is '%s'\n", ps);
4585 if (*ps == ':')
4586 v = gettermcapstring(ps + 1);
4587 else
4588 {
4589 if (*ps == '{')
4590 ps++;
4591 v = xbuf;
4592 if (!strcmp(ps, "TERM"))
4593 v = display ? D_termname : "unknown";
4594 else if (!strcmp(ps, "COLUMNS"))
4595 sprintf(xbuf, "%d", display ? D_width : -1);
4596 else if (!strcmp(ps, "LINES"))
4597 sprintf(xbuf, "%d", display ? D_height : -1);
4598 else if (!strcmp(ps, "PID"))
4599 sprintf(xbuf, "%d", getpid());
4600 else if (!strcmp(ps, "STY"))
4601 v = SockName;
4602 else
4603 v = getenv(ps);
4604 }
4605 *pe = op;
4606 vl = v ? strlen(v) : 0;
4607 if (vl)
4608 {
4609 debug1("- sub is '%s'\n", v);
4610 if (p - pp < vl)
4611 {
4612 int right = buf + bufl - (p + strlen(p) + 1);
4613 if (right > 0)
4614 {
4615 bcopy(p, p + right, strlen(p) + 1);
4616 p += right;
4617 }
4618 }
4619 if (p - pp < vl)
4620 {
4621 Msg(0, "%s: no space left for variable expansion.", rc_name);
4622 return 0;
4623 }
4624 bcopy(v, pp, vl);
4625 pp += vl;
4626 }
4627 continue;
4628 }
4629 else if (delim != '\'' && *p == '^' && p[1])
4630 {
4631 p++;
4632 *pp++ = *p == '?' ? '\177' : *p & 0x1f;
4633 }
4634 else if (delim == 0 && (*p == '\'' || *p == '"'))
4635 delim = *p;
4636 else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n'))
4637 break;
4638 else
4639 *pp++ = *p;
4640 p++;
4641 }
4642 if (delim)
4643 {
4644 Msg(0, "%s: Missing %c quote.", rc_name, delim);
4645 return 0;
4646 }
4647 if (*p)
4648 p++;
4649 *pp = 0;
4650 debug2("- arg done, '%s' rest %s\n", ap[-1], p);
4651 *lp++ = pp - ap[-1];
4652 pp++;
4653 }
4654 }
4655
4656 void
4657 SetEscape(u, e, me)
4658 struct acluser *u;
4659 int e, me;
4660 {
4661 if (u)
4662 {
4663 u->u_Esc = e;
4664 u->u_MetaEsc = me;
4665 }
4666 else
4667 {
4668 if (users)
4669 {
4670 if (DefaultEsc >= 0)
4671 ClearAction(&ktab[DefaultEsc]);
4672 if (DefaultMetaEsc >= 0)
4673 ClearAction(&ktab[DefaultMetaEsc]);
4674 }
4675 DefaultEsc = e;
4676 DefaultMetaEsc = me;
4677 if (users)
4678 {
4679 if (DefaultEsc >= 0)
4680 {
4681 ClearAction(&ktab[DefaultEsc]);
4682 ktab[DefaultEsc].nr = RC_OTHER;
4683 }
4684 if (DefaultMetaEsc >= 0)
4685 {
4686 ClearAction(&ktab[DefaultMetaEsc]);
4687 ktab[DefaultMetaEsc].nr = RC_META;
4688 }
4689 }
4690 }
4691 }
4692
4693 int
4694 ParseSwitch(act, var)
4695 struct action *act;
4696 int *var;
4697 {
4698 if (*act->args == 0)
4699 {
4700 *var ^= 1;
4701 return 0;
4702 }
4703 return ParseOnOff(act, var);
4704 }
4705
4706 static int
4707 ParseOnOff(act, var)
4708 struct action *act;
4709 int *var;
4710 {
4711 register int num = -1;
4712 char **args = act->args;
4713
4714 if (args[1] == 0)
4715 {
4716 if (strcmp(args[0], "on") == 0)
4717 num = 1;
4718 else if (strcmp(args[0], "off") == 0)
4719 num = 0;
4720 }
4721 if (num < 0)
4722 {
4723 Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name);
4724 return -1;
4725 }
4726 *var = num;
4727 return 0;
4728 }
4729
4730 int
4731 ParseSaveStr(act, var)
4732 struct action *act;
4733 char **var;
4734 {
4735 char **args = act->args;
4736 if (*args == 0 || args[1])
4737 {
4738 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4739 return -1;
4740 }
4741 if (*var)
4742 free(*var);
4743 *var = SaveStr(*args);
4744 return 0;
4745 }
4746
4747 int
4748 ParseNum(act, var)
4749 struct action *act;
4750 int *var;
4751 {
4752 int i;
4753 char *p, **args = act->args;
4754
4755 p = *args;
4756 if (p == 0 || *p == 0 || args[1])
4757 {
4758 Msg(0, "%s: %s: invalid argument. Give one argument.",
4759 rc_name, comms[act->nr].name);
4760 return -1;
4761 }
4762 i = 0;
4763 while (*p)
4764 {
4765 if (*p >= '0' && *p <= '9')
4766 i = 10 * i + (*p - '0');
4767 else
4768 {
4769 Msg(0, "%s: %s: invalid argument. Give numeric argument.",
4770 rc_name, comms[act->nr].name);
4771 return -1;
4772 }
4773 p++;
4774 }
4775 debug1("ParseNum got %d\n", i);
4776 *var = i;
4777 return 0;
4778 }
4779
4780 static int
4781 ParseNum1000(act, var)
4782 struct action *act;
4783 int *var;
4784 {
4785 int i;
4786 char *p, **args = act->args;
4787 int dig = 0;
4788
4789 p = *args;
4790 if (p == 0 || *p == 0 || args[1])
4791 {
4792 Msg(0, "%s: %s: invalid argument. Give one argument.",
4793 rc_name, comms[act->nr].name);
4794 return -1;
4795 }
4796 i = 0;
4797 while (*p)
4798 {
4799 if (*p >= '0' && *p <= '9')
4800 {
4801 if (dig < 4)
4802 i = 10 * i + (*p - '0');
4803 else if (dig == 4 && *p >= '5')
4804 i++;
4805 if (dig)
4806 dig++;
4807 }
4808 else if (*p == '.' && !dig)
4809 dig++;
4810 else
4811 {
4812 Msg(0, "%s: %s: invalid argument. Give floating point argument.",
4813 rc_name, comms[act->nr].name);
4814 return -1;
4815 }
4816 p++;
4817 }
4818 if (dig == 0)
4819 i *= 1000;
4820 else
4821 while (dig++ < 4)
4822 i *= 10;
4823 if (i < 0)
4824 i = (int)((unsigned int)~0 >> 1);
4825 debug1("ParseNum1000 got %d\n", i);
4826 *var = i;
4827 return 0;
4828 }
4829
4830 static struct win *
4831 WindowByName(s)
4832 char *s;
4833 {
4834 struct win *p;
4835
4836 for (p = windows; p; p = p->w_next)
4837 if (!strcmp(p->w_title, s))
4838 return p;
4839 for (p = windows; p; p = p->w_next)
4840 if (!strncmp(p->w_title, s, strlen(s)))
4841 return p;
4842 return 0;
4843 }
4844
4845 static int
4846 WindowByNumber(str)
4847 char *str;
4848 {
4849 int i;
4850 char *s;
4851
4852 for (i = 0, s = str; *s; s++)
4853 {
4854 if (*s < '0' || *s > '9')
4855 break;
4856 i = i * 10 + (*s - '0');
4857 }
4858 return *s ? -1 : i;
4859 }
4860
4861 /*
4862 * Get window number from Name or Number string.
4863 * Numbers are tried first, then names, a prefix match suffices.
4864 * Be careful when assigning numeric strings as WindowTitles.
4865 */
4866 int
4867 WindowByNoN(str)
4868 char *str;
4869 {
4870 int i;
4871 struct win *p;
4872
4873 if ((i = WindowByNumber(str)) < 0 || i >= MAXWIN)
4874 {
4875 if ((p = WindowByName(str)))
4876 return p->w_number;
4877 return -1;
4878 }
4879 return i;
4880 }
4881
4882 static int
4883 ParseWinNum(act, var)
4884 struct action *act;
4885 int *var;
4886 {
4887 char **args = act->args;
4888 int i = 0;
4889
4890 if (*args == 0 || args[1])
4891 {
4892 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4893 return -1;
4894 }
4895
4896 i = WindowByNoN(*args);
4897 if (i < 0)
4898 {
4899 Msg(0, "%s: %s: invalid argument. Give window number or name.",
4900 rc_name, comms[act->nr].name);
4901 return -1;
4902 }
4903 debug1("ParseWinNum got %d\n", i);
4904 *var = i;
4905 return 0;
4906 }
4907
4908 static int
4909 ParseBase(act, p, var, base, bname)
4910 struct action *act;
4911 char *p;
4912 int *var;
4913 int base;
4914 char *bname;
4915 {
4916 int i = 0;
4917 int c;
4918
4919 if (*p == 0)
4920 {
4921 Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name);
4922 return -1;
4923 }
4924 while ((c = *p++))
4925 {
4926 if (c >= 'a' && c <= 'z')
4927 c -= 'a' - 'A';
4928 if (c >= 'A' && c <= 'Z')
4929 c -= 'A' - ('0' + 10);
4930 c -= '0';
4931 if (c < 0 || c >= base)
4932 {
4933 Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname);
4934 return -1;
4935 }
4936 i = base * i + c;
4937 }
4938 debug1("ParseBase got %d\n", i);
4939 *var = i;
4940 return 0;
4941 }
4942
4943 static int
4944 IsNum(s, base)
4945 register char *s;
4946 register int base;
4947 {
4948 for (base += '0'; *s; ++s)
4949 if (*s < '0' || *s > base)
4950 return 0;
4951 return 1;
4952 }
4953
4954 int
4955 IsNumColon(s, base, p, psize)
4956 int base, psize;
4957 char *s, *p;
4958 {
4959 char *q;
4960 if ((q = rindex(s, ':')) != 0)
4961 {
4962 strncpy(p, q + 1, psize - 1);
4963 p[psize - 1] = '\0';
4964 *q = '\0';
4965 }
4966 else
4967 *p = '\0';
4968 return IsNum(s, base);
4969 }
4970
4971 void
4972 SwitchWindow(n)
4973 int n;
4974 {
4975 struct win *p;
4976
4977 debug1("SwitchWindow %d\n", n);
4978 if (n < 0 || n >= MAXWIN)
4979 {
4980 ShowWindows(-1);
4981 return;
4982 }
4983 if ((p = wtab[n]) == 0)
4984 {
4985 ShowWindows(n);
4986 return;
4987 }
4988 if (display == 0)
4989 {
4990 fore = p;
4991 return;
4992 }
4993 if (p == D_fore)
4994 {
4995 Msg(0, "This IS window %d (%s).", n, p->w_title);
4996 return;
4997 }
4998 #ifdef MULTIUSER
4999 if (AclCheckPermWin(D_user, ACL_READ, p))
5000 {
5001 Msg(0, "Access to window %d denied.", p->w_number);
5002 return;
5003 }
5004 #endif
5005 SetForeWindow(p);
5006 Activate(fore->w_norefresh);
5007 }
5008
5009
5010 void
5011 SetCanvasWindow(cv, wi)
5012 struct canvas *cv;
5013 struct win *wi;
5014 {
5015 struct win *p = 0, **pp;
5016 struct layer *l;
5017 struct canvas *cvp, **cvpp;
5018
5019 l = cv->c_layer;
5020 display = cv->c_display;
5021
5022 if (l)
5023 {
5024 /* remove old layer */
5025 for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
5026 if (cvp == cv)
5027 break;
5028 ASSERT(cvp);
5029 *cvpp = cvp->c_lnext;
5030
5031 p = Layer2Window(l);
5032 l = cv->c_layer;
5033 cv->c_layer = 0;
5034
5035 if (p && cv == D_forecv)
5036 {
5037 #ifdef MULTIUSER
5038 ReleaseAutoWritelock(display, p);
5039 #endif
5040 if (p->w_silence)
5041 {
5042 SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
5043 evenq(&p->w_silenceev);
5044 }
5045 D_other = fore;
5046 D_fore = 0;
5047 }
5048 if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
5049 KillLayerChain(l);
5050 }
5051
5052 /* find right layer to display on canvas */
5053 if (wi && wi->w_type != W_TYPE_GROUP)
5054 {
5055 l = &wi->w_layer;
5056 if (wi->w_savelayer && (wi->w_blocked || wi->w_savelayer->l_cvlist == 0))
5057 l = wi->w_savelayer;
5058 }
5059 else
5060 {
5061 l = &cv->c_blank;
5062 if (wi)
5063 l->l_data = (char *)wi;
5064 else
5065 l->l_data = 0;
5066 }
5067
5068 /* add our canvas to the layer's canvaslist */
5069 ASSERT(l->l_cvlist != cv);
5070 cv->c_lnext = l->l_cvlist;
5071 l->l_cvlist = cv;
5072 cv->c_layer = l;
5073 cv->c_xoff = cv->c_xs;
5074 cv->c_yoff = cv->c_ys;
5075 RethinkViewportOffsets(cv);
5076
5077 if (flayer == 0)
5078 flayer = l;
5079
5080 if (wi && wi->w_type == W_TYPE_GROUP)
5081 {
5082 /* auto-start windowlist on groups */
5083 struct display *d = display;
5084 struct layer *oldflayer = flayer;
5085 flayer = l;
5086 display_wlist(0, 0, wi);
5087 flayer = oldflayer;
5088 display = d;
5089 }
5090
5091 if (wi && D_other == wi)
5092 D_other = wi->w_next; /* Might be 0, but that's OK. */
5093 if (cv == D_forecv)
5094 {
5095 D_fore = wi;
5096 fore = D_fore; /* XXX ? */
5097 if (wi)
5098 {
5099 #ifdef MULTIUSER
5100 ObtainAutoWritelock(display, wi);
5101 #endif
5102 /*
5103 * Place the window at the head of the most-recently-used list
5104 */
5105 if (windows != wi)
5106 {
5107 for (pp = &windows; (p = *pp); pp = &p->w_next)
5108 if (p == wi)
5109 break;
5110 ASSERT(p);
5111 *pp = p->w_next;
5112 p->w_next = windows;
5113 windows = p;
5114 WListLinkChanged();
5115 }
5116 }
5117 }
5118 }
5119
5120
5121 /*
5122 * SetForeWindow changes the window in the input focus of the display.
5123 * Puts window wi in canvas display->d_forecv.
5124 */
5125 void
5126 SetForeWindow(wi)
5127 struct win *wi;
5128 {
5129 struct win *p;
5130 if (display == 0)
5131 {
5132 fore = wi;
5133 return;
5134 }
5135 p = Layer2Window(D_forecv->c_layer);
5136 SetCanvasWindow(D_forecv, wi);
5137 if (p)
5138 WindowChanged(p, 'u');
5139 if (wi)
5140 WindowChanged(wi, 'u');
5141 flayer = D_forecv->c_layer;
5142 /* Activate called afterwards, so no RefreshHStatus needed */
5143 }
5144
5145
5146 /*****************************************************************/
5147
5148 /*
5149 * Activate - make fore window active
5150 * norefresh = -1 forces a refresh, disregard all_norefresh then.
5151 */
5152 void
5153 Activate(norefresh)
5154 int norefresh;
5155 {
5156 debug1("Activate(%d)\n", norefresh);
5157 if (display == 0)
5158 return;
5159 if (D_status)
5160 {
5161 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
5162 RemoveStatus();
5163 }
5164
5165 if (MayResizeLayer(D_forecv->c_layer))
5166 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display);
5167
5168 fore = D_fore;
5169 if (fore)
5170 {
5171 /* XXX ? */
5172 if (fore->w_monitor != MON_OFF)
5173 fore->w_monitor = MON_ON;
5174 fore->w_bell = BELL_ON;
5175 WindowChanged(fore, 'f');
5176
5177 #if 0
5178 if (ResizeDisplay(fore->w_width, fore->w_height))
5179 {
5180 debug2("Cannot resize from (%d,%d)", D_width, D_height);
5181 debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height);
5182 DoResize(D_width, D_height);
5183 }
5184 #endif
5185 }
5186 Redisplay(norefresh + all_norefresh);
5187 }
5188
5189
5190 static int
5191 NextWindow()
5192 {
5193 register struct win **pp;
5194 int n = fore ? fore->w_number : MAXWIN;
5195 struct win *group = fore ? fore->w_group : 0;
5196
5197 for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++)
5198 {
5199 if (pp == wtab + MAXWIN)
5200 pp = wtab;
5201 if (*pp)
5202 {
5203 if (!fore || group == (*pp)->w_group)
5204 break;
5205 }
5206 }
5207 if (pp == wtab + n)
5208 return -1;
5209 return pp - wtab;
5210 }
5211
5212 static int
5213 PreviousWindow()
5214 {
5215 register struct win **pp;
5216 int n = fore ? fore->w_number : -1;
5217 struct win *group = fore ? fore->w_group : 0;
5218
5219 for (pp = wtab + n - 1; pp != wtab + n; pp--)
5220 {
5221 if (pp == wtab - 1)
5222 pp = wtab + MAXWIN - 1;
5223 if (*pp)
5224 {
5225 if (!fore || group == (*pp)->w_group)
5226 break;
5227 }
5228 }
5229 if (pp == wtab + n)
5230 return -1;
5231 return pp - wtab;
5232 }
5233
5234 static int
5235 MoreWindows()
5236 {
5237 char *m = "No other window.";
5238 if (windows && (fore == 0 || windows->w_next))
5239 return 1;
5240 if (fore == 0)
5241 {
5242 Msg(0, "No window available");
5243 return 0;
5244 }
5245 Msg(0, m, fore->w_number); /* other arg for nethack */
5246 return 0;
5247 }
5248
5249 static void
5250 UpdateLayoutCanvas(cv, wi)
5251 struct canvas *cv;
5252 struct win *wi;
5253 {
5254 for (; cv; cv = cv->c_slnext)
5255 {
5256 if (cv->c_layer && Layer2Window(cv->c_layer) == wi)
5257 {
5258 /* A simplistic version of SetCanvasWindow(cv, 0) */
5259 struct layer *l = cv->c_layer;
5260 cv->c_layer = 0;
5261 if (l->l_cvlist == 0 && (wi == 0 || l != wi->w_savelayer))
5262 KillLayerChain(l);
5263 l = &cv->c_blank;
5264 l->l_data = 0;
5265 if (l->l_cvlist != cv)
5266 {
5267 cv->c_lnext = l->l_cvlist;
5268 l->l_cvlist = cv;
5269 }
5270 cv->c_layer = l;
5271 /* Do not end here. Multiple canvases can have the same window */
5272 }
5273
5274 if (cv->c_slperp)
5275 UpdateLayoutCanvas(cv->c_slperp, wi);
5276 }
5277 }
5278
5279 void
5280 KillWindow(wi)
5281 struct win *wi;
5282 {
5283 struct win **pp, *p;
5284 struct canvas *cv;
5285 int gotone;
5286 struct layout *lay;
5287
5288 /*
5289 * Remove window from linked list.
5290 */
5291 for (pp = &windows; (p = *pp); pp = &p->w_next)
5292 if (p == wi)
5293 break;
5294 ASSERT(p);
5295 *pp = p->w_next;
5296 wi->w_inlen = 0;
5297 wtab[wi->w_number] = 0;
5298
5299 if (windows == 0)
5300 {
5301 FreeWindow(wi);
5302 Finit(0);
5303 }
5304
5305 /*
5306 * switch to different window on all canvases
5307 */
5308 for (display = displays; display; display = display->d_next)
5309 {
5310 gotone = 0;
5311 for (cv = D_cvlist; cv; cv = cv->c_next)
5312 {
5313 if (Layer2Window(cv->c_layer) != wi)
5314 continue;
5315 /* switch to other window */
5316 SetCanvasWindow(cv, FindNiceWindow(D_other, 0));
5317 gotone = 1;
5318 }
5319 if (gotone)
5320 {
5321 #ifdef ZMODEM
5322 if (wi->w_zdisplay == display)
5323 {
5324 D_blocked = 0;
5325 D_readev.condpos = D_readev.condneg = 0;
5326 }
5327 #endif
5328 Activate(-1);
5329 }
5330 }
5331
5332 /* do the same for the layouts */
5333 for (lay = layouts; lay; lay = lay->lay_next)
5334 UpdateLayoutCanvas(&lay->lay_canvas, wi);
5335
5336 FreeWindow(wi);
5337 WindowChanged((struct win *)0, 'w');
5338 WindowChanged((struct win *)0, 'W');
5339 WindowChanged((struct win *)0, 0);
5340 }
5341
5342 static void
5343 LogToggle(on)
5344 int on;
5345 {
5346 char buf[1024];
5347
5348 if ((fore->w_log != 0) == on)
5349 {
5350 if (display && !*rc_name)
5351 Msg(0, "You are %s logging.", on ? "already" : "not");
5352 return;
5353 }
5354 if (fore->w_log != 0)
5355 {
5356 Msg(0, "Logfile \"%s\" closed.", fore->w_log->name);
5357 logfclose(fore->w_log);
5358 fore->w_log = 0;
5359 WindowChanged(fore, 'f');
5360 return;
5361 }
5362 if (DoStartLog(fore, buf, sizeof(buf)))
5363 {
5364 Msg(errno, "Error opening logfile \"%s\"", buf);
5365 return;
5366 }
5367 if (ftell(fore->w_log->fp) == 0)
5368 Msg(0, "Creating logfile \"%s\".", fore->w_log->name);
5369 else
5370 Msg(0, "Appending to logfile \"%s\".", fore->w_log->name);
5371 WindowChanged(fore, 'f');
5372 }
5373
5374 char *
5375 AddWindows(buf, len, flags, where)
5376 char *buf;
5377 int len;
5378 int flags;
5379 int where;
5380 {
5381 register char *s, *ss;
5382 register struct win **pp, *p;
5383 register char *cmd;
5384 int l;
5385
5386 s = ss = buf;
5387 if ((flags & 8) && where < 0)
5388 {
5389 *s = 0;
5390 return ss;
5391 }
5392 for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + MAXWIN; pp++)
5393 {
5394 int rend = -1;
5395 if (pp - wtab == where && ss == buf)
5396 ss = s;
5397 if ((p = *pp) == 0)
5398 continue;
5399 if ((flags & 1) && display && p == D_fore)
5400 continue;
5401 if (D_fore && D_fore->w_group != p->w_group)
5402 continue;
5403
5404 cmd = p->w_title;
5405 l = strlen(cmd);
5406 if (l > 20)
5407 l = 20;
5408 if (s - buf + l > len - 24)
5409 break;
5410 if (s > buf || (flags & 4))
5411 {
5412 *s++ = ' ';
5413 *s++ = ' ';
5414 }
5415 if (p->w_number == where)
5416 {
5417 ss = s;
5418 if (flags & 8)
5419 break;
5420 }
5421 if (!(flags & 4) || where < 0 || ((flags & 4) && where < p->w_number))
5422 {
5423 if (p->w_monitor == MON_DONE && renditions[REND_MONITOR] != -1)
5424 rend = renditions[REND_MONITOR];
5425 else if ((p->w_bell == BELL_DONE || p->w_bell == BELL_FOUND) && renditions[REND_BELL] != -1)
5426 rend = renditions[REND_BELL];
5427 }
5428 if (rend != -1)
5429 AddWinMsgRend(s, rend);
5430 sprintf(s, "%d", p->w_number);
5431 s += strlen(s);
5432 if (display && p == D_fore)
5433 *s++ = '*';
5434 if (!(flags & 2))
5435 {
5436 if (display && p == D_other)
5437 *s++ = '-';
5438 s = AddWindowFlags(s, len, p);
5439 }
5440 *s++ = ' ';
5441 strncpy(s, cmd, l);
5442 s += l;
5443 if (rend != -1)
5444 AddWinMsgRend(s, -1);
5445 }
5446 *s = 0;
5447 return ss;
5448 }
5449
5450 char *
5451 AddWindowFlags(buf, len, p)
5452 char *buf;
5453 int len;
5454 struct win *p;
5455 {
5456 char *s = buf;
5457 if (p == 0 || len < 12)
5458 {
5459 *s = 0;
5460 return s;
5461 }
5462 #if 0
5463 if (display && p == D_fore)
5464 *s++ = '*';
5465 if (display && p == D_other)
5466 *s++ = '-';
5467 #endif
5468 if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext)
5469 *s++ = '&';
5470 if (p->w_monitor == MON_DONE
5471 #ifdef MULTIUSER
5472 && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5473 #endif
5474 )
5475 *s++ = '@';
5476 if (p->w_bell == BELL_DONE)
5477 *s++ = '!';
5478 #ifdef UTMPOK
5479 if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1)
5480 *s++ = '$';
5481 #endif
5482 if (p->w_log != 0)
5483 {
5484 strcpy(s, "(L)");
5485 s += 3;
5486 }
5487 if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP)
5488 *s++ = 'Z';
5489 *s = 0;
5490 return s;
5491 }
5492
5493 char *
5494 AddOtherUsers(buf, len, p)
5495 char *buf;
5496 int len;
5497 struct win *p;
5498 {
5499 struct display *d, *olddisplay = display;
5500 struct canvas *cv;
5501 char *s;
5502 int l;
5503
5504 s = buf;
5505 for (display = displays; display; display = display->d_next)
5506 {
5507 if (olddisplay && D_user == olddisplay->d_user)
5508 continue;
5509 for (cv = D_cvlist; cv; cv = cv->c_next)
5510 if (Layer2Window(cv->c_layer) == p)
5511 break;
5512 if (!cv)
5513 continue;
5514 for (d = displays; d && d != display; d = d->d_next)
5515 if (D_user == d->d_user)
5516 break;
5517 if (d && d != display)
5518 continue;
5519 if (len > 1 && s != buf)
5520 {
5521 *s++ = ',';
5522 len--;
5523 }
5524 l = strlen(D_user->u_name);
5525 if (l + 1 > len)
5526 break;
5527 strcpy(s, D_user->u_name);
5528 s += l;
5529 len -= l;
5530 }
5531 *s = 0;
5532 display = olddisplay;
5533 return s;
5534 }
5535
5536 void
5537 ShowWindows(where)
5538 int where;
5539 {
5540 char buf[1024];
5541 char *s, *ss;
5542
5543 if (!display)
5544 return;
5545 if (where == -1 && D_fore)
5546 where = D_fore->w_number;
5547 ss = AddWindows(buf, sizeof(buf), 0, where);
5548 s = buf + strlen(buf);
5549 if (ss - buf > D_width / 2)
5550 {
5551 ss -= D_width / 2;
5552 if (s - ss < D_width)
5553 {
5554 ss = s - D_width;
5555 if (ss < buf)
5556 ss = buf;
5557 }
5558 }
5559 else
5560 ss = buf;
5561 Msg(0, "%s", ss);
5562 }
5563
5564 static void
5565 ShowInfo()
5566 {
5567 char buf[512], *p;
5568 register struct win *wp = fore;
5569 register int i;
5570
5571 if (wp == 0)
5572 {
5573 Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height);
5574 return;
5575 }
5576 p = buf;
5577 if (buf < (p += GetAnsiStatus(wp, p)))
5578 *p++ = ' ';
5579 sprintf(p, "(%d,%d)/(%d,%d)",
5580 wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height);
5581 #ifdef COPY_PASTE
5582 sprintf(p += strlen(p), "+%d", wp->w_histheight);
5583 #endif
5584 sprintf(p += strlen(p), " %c%sflow",
5585 (wp->w_flow & FLOW_NOW) ? '+' : '-',
5586 (wp->w_flow & FLOW_AUTOFLAG) ? "" :
5587 ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)"));
5588 if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap");
5589 if (wp->w_insert) sprintf(p += strlen(p), " ins");
5590 if (wp->w_origin) sprintf(p += strlen(p), " org");
5591 if (wp->w_keypad) sprintf(p += strlen(p), " app");
5592 if (wp->w_log) sprintf(p += strlen(p), " log");
5593 if (wp->w_monitor != MON_OFF
5594 #ifdef MULTIUSER
5595 && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5596 #endif
5597 )
5598 sprintf(p += strlen(p), " mon");
5599 if (wp->w_mouse) sprintf(p += strlen(p), " mouse");
5600 #ifdef COLOR
5601 if (wp->w_bce) sprintf(p += strlen(p), " bce");
5602 #endif
5603 if (!wp->w_c1) sprintf(p += strlen(p), " -c1");
5604 if (wp->w_norefresh) sprintf(p += strlen(p), " nored");
5605
5606 p += strlen(p);
5607 #ifdef FONT
5608 # ifdef ENCODINGS
5609 if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0))
5610 {
5611 *p++ = ' ';
5612 strcpy(p, EncodingName(wp->w_encoding));
5613 p += strlen(p);
5614 }
5615 # ifdef UTF8
5616 if (wp->w_encoding != UTF8)
5617 # endif
5618 # endif
5619 if (D_CC0 || (D_CS0 && *D_CS0))
5620 {
5621 if (wp->w_gr == 2)
5622 {
5623 sprintf(p, " G%c", wp->w_Charset + '0');
5624 if (wp->w_FontE >= ' ')
5625 p[3] = wp->w_FontE;
5626 else
5627 {
5628 p[3] = '^';
5629 p[4] = wp->w_FontE ^ 0x40;
5630 p++;
5631 }
5632 p[4] = '[';
5633 p++;
5634 }
5635 else if (wp->w_gr)
5636 sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0');
5637 else
5638 sprintf(p, " G%c[", wp->w_Charset + '0');
5639 p += 4;
5640 for (i = 0; i < 4; i++)
5641 {
5642 if (wp->w_charsets[i] == ASCII)
5643 *p++ = 'B';
5644 else if (wp->w_charsets[i] >= ' ')
5645 *p++ = wp->w_charsets[i];
5646 else
5647 {
5648 *p++ = '^';
5649 *p++ = wp->w_charsets[i] ^ 0x40;
5650 }
5651 }
5652 *p++ = ']';
5653 *p = 0;
5654 }
5655 #endif
5656
5657 if (wp->w_type == W_TYPE_PLAIN)
5658 {
5659 /* add info about modem control lines */
5660 *p++ = ' ';
5661 TtyGetModemStatus(wp->w_ptyfd, p);
5662 }
5663 #ifdef BUILTIN_TELNET
5664 else if (wp->w_type == W_TYPE_TELNET)
5665 {
5666 *p++ = ' ';
5667 TelStatus(wp, p, sizeof(buf) - 1 - (p - buf));
5668 }
5669 #endif
5670 Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title);
5671 }
5672
5673 static void
5674 ShowDInfo()
5675 {
5676 char buf[512], *p;
5677 if (display == 0)
5678 return;
5679 p = buf;
5680 sprintf(p, "(%d,%d)", D_width, D_height),
5681 p += strlen(p);
5682 #ifdef ENCODINGS
5683 if (D_encoding)
5684 {
5685 *p++ = ' ';
5686 strcpy(p, EncodingName(D_encoding));
5687 p += strlen(p);
5688 }
5689 #endif
5690 if (D_CXT)
5691 {
5692 strcpy(p, " xterm");
5693 p += strlen(p);
5694 }
5695 #ifdef COLOR
5696 if (D_hascolor)
5697 {
5698 strcpy(p, " color");
5699 p += strlen(p);
5700 }
5701 #endif
5702 #ifdef FONT
5703 if (D_CG0)
5704 {
5705 strcpy(p, " iso2022");
5706 p += strlen(p);
5707 }
5708 else if (D_CS0 && *D_CS0)
5709 {
5710 strcpy(p, " altchar");
5711 p += strlen(p);
5712 }
5713 #endif
5714 Msg(0, "%s", buf);
5715 }
5716
5717 static void
5718 AKAfin(buf, len, data)
5719 char *buf;
5720 int len;
5721 char *data; /* dummy */
5722 {
5723 ASSERT(display);
5724 if (len && fore)
5725 ChangeAKA(fore, buf, strlen(buf));
5726 }
5727
5728 static void
5729 InputAKA()
5730 {
5731 char *s, *ss;
5732 int n;
5733 Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0);
5734 s = fore->w_title;
5735 if (!s)
5736 return;
5737 for (; *s; s++)
5738 {
5739 if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f)
5740 continue;
5741 ss = s;
5742 n = 1;
5743 LayProcess(&ss, &n);
5744 }
5745 }
5746
5747 static void
5748 Colonfin(buf, len, data)
5749 char *buf;
5750 int len;
5751 char *data; /* dummy */
5752 {
5753 char mbuf[256];
5754
5755 RemoveStatus();
5756 if (buf[len] == '\t')
5757 {
5758 int m, x;
5759 int l = 0, r = RC_LAST;
5760 int showmessage = 0;
5761 char *s = buf;
5762
5763 while (*s && s - buf < len)
5764 if (*s++ == ' ')
5765 return;
5766
5767 /* Showing a message when there's no hardstatus or caption cancels the input */
5768 if (display &&
5769 (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)))
5770 showmessage = 1;
5771
5772 while (l <= r)
5773 {
5774 m = (l + r) / 2;
5775 x = strncmp(buf, comms[m].name, len);
5776 if (x > 0)
5777 l = m + 1;
5778 else if (x < 0)
5779 r = m - 1;
5780 else
5781 {
5782 s = mbuf;
5783 for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--)
5784 ;
5785 for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++)
5786 s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name);
5787 if (l < m - 1)
5788 {
5789 if (showmessage)
5790 Msg(0, "Possible commands:%s", mbuf);
5791 }
5792 else
5793 {
5794 s = mbuf;
5795 len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len);
5796 if (len > 0 && len < sizeof(mbuf))
5797 LayProcess(&s, &len);
5798 }
5799 break;
5800 }
5801 }
5802 if (l > r && showmessage)
5803 Msg(0, "No commands matching '%*s'", len, buf);
5804 return;
5805 }
5806
5807 if (!len || buf[len])
5808 return;
5809
5810 len = strlen(buf) + 1;
5811 if (len > (int)sizeof(mbuf))
5812 RcLine(buf, len);
5813 else
5814 {
5815 bcopy(buf, mbuf, len);
5816 RcLine(mbuf, sizeof mbuf);
5817 }
5818 }
5819
5820 static void
5821 SelectFin(buf, len, data)
5822 char *buf;
5823 int len;
5824 char *data; /* dummy */
5825 {
5826 int n;
5827
5828 if (!len || !display)
5829 return;
5830 if (len == 1 && *buf == '-')
5831 {
5832 SetForeWindow((struct win *)0);
5833 Activate(0);
5834 return;
5835 }
5836 if ((n = WindowByNoN(buf)) < 0)
5837 return;
5838 SwitchWindow(n);
5839 }
5840
5841 static void
5842 SelectLayoutFin(buf, len, data)
5843 char *buf;
5844 int len;
5845 char *data; /* dummy */
5846 {
5847 struct layout *lay;
5848
5849 if (!len || !display)
5850 return;
5851 if (len == 1 && *buf == '-')
5852 {
5853 LoadLayout((struct layout *)0, (struct canvas *)0);
5854 Activate(0);
5855 return;
5856 }
5857 lay = FindLayout(buf);
5858 if (!lay)
5859 Msg(0, "No such layout\n");
5860 else if (lay == D_layout)
5861 Msg(0, "This IS layout %d (%s).\n", lay->lay_number, lay->lay_title);
5862 else
5863 {
5864 LoadLayout(lay, &D_canvas);
5865 Activate(0);
5866 }
5867 }
5868
5869
5870 static void
5871 InputSelect()
5872 {
5873 Input("Switch to window: ", 20, INP_COOKED, SelectFin, NULL, 0);
5874 }
5875
5876 static char setenv_var[31];
5877
5878
5879 static void
5880 SetenvFin1(buf, len, data)
5881 char *buf;
5882 int len;
5883 char *data; /* dummy */
5884 {
5885 if (!len || !display)
5886 return;
5887 InputSetenv(buf);
5888 }
5889
5890 static void
5891 SetenvFin2(buf, len, data)
5892 char *buf;
5893 int len;
5894 char *data; /* dummy */
5895 {
5896 if (!len || !display)
5897 return;
5898 debug2("SetenvFin2: setenv '%s' '%s'\n", setenv_var, buf);
5899 xsetenv(setenv_var, buf);
5900 MakeNewEnv();
5901 }
5902
5903 static void
5904 InputSetenv(arg)
5905 char *arg;
5906 {
5907 static char setenv_buf[50 + sizeof(setenv_var)]; /* need to be static here, cannot be freed */
5908
5909 if (arg)
5910 {
5911 strncpy(setenv_var, arg, sizeof(setenv_var) - 1);
5912 sprintf(setenv_buf, "Enter value for %s: ", setenv_var);
5913 Input(setenv_buf, 30, INP_COOKED, SetenvFin2, NULL, 0);
5914 }
5915 else
5916 Input("Setenv: Enter variable name: ", 30, INP_COOKED, SetenvFin1, NULL, 0);
5917 }
5918
5919 /*
5920 * the following options are understood by this parser:
5921 * -f, -f0, -f1, -fy, -fa
5922 * -t title, -T terminal-type, -h height-of-scrollback,
5923 * -ln, -l0, -ly, -l1, -l
5924 * -a, -M, -L
5925 */
5926 void
5927 DoScreen(fn, av)
5928 char *fn, **av;
5929 {
5930 struct NewWindow nwin;
5931 register int num;
5932 char buf[20];
5933
5934 nwin = nwin_undef;
5935 while (av && *av && av[0][0] == '-')
5936 {
5937 if (av[0][1] == '-')
5938 {
5939 av++;
5940 break;
5941 }
5942 switch (av[0][1])
5943 {
5944 case 'f':
5945 switch (av[0][2])
5946 {
5947 case 'n':
5948 case '0':
5949 nwin.flowflag = FLOW_NOW * 0;
5950 break;
5951 case 'y':
5952 case '1':
5953 case '\0':
5954 nwin.flowflag = FLOW_NOW * 1;
5955 break;
5956 case 'a':
5957 nwin.flowflag = FLOW_AUTOFLAG;
5958 break;
5959 default:
5960 break;
5961 }
5962 break;
5963 case 't': /* no more -k */
5964 if (av[0][2])
5965 nwin.aka = &av[0][2];
5966 else if (*++av)
5967 nwin.aka = *av;
5968 else
5969 --av;
5970 break;
5971 case 'T':
5972 if (av[0][2])
5973 nwin.term = &av[0][2];
5974 else if (*++av)
5975 nwin.term = *av;
5976 else
5977 --av;
5978 break;
5979 case 'h':
5980 if (av[0][2])
5981 nwin.histheight = atoi(av[0] + 2);
5982 else if (*++av)
5983 nwin.histheight = atoi(*av);
5984 else
5985 --av;
5986 break;
5987 #ifdef LOGOUTOK
5988 case 'l':
5989 switch (av[0][2])
5990 {
5991 case 'n':
5992 case '0':
5993 nwin.lflag = 0;
5994 break;
5995 case 'y':
5996 case '1':
5997 case '\0':
5998 nwin.lflag = 1;
5999 break;
6000 case 'a':
6001 nwin.lflag = 3;
6002 break;
6003 default:
6004 break;
6005 }
6006 break;
6007 #endif
6008 case 'a':
6009 nwin.aflag = 1;
6010 break;
6011 case 'M':
6012 nwin.monitor = MON_ON;
6013 break;
6014 case 'L':
6015 nwin.Lflag = 1;
6016 break;
6017 default:
6018 Msg(0, "%s: screen: invalid option -%c.", fn, av[0][1]);
6019 break;
6020 }
6021 ++av;
6022 }
6023 num = 0;
6024 if (av && *av && IsNumColon(*av, 10, buf, sizeof(buf)))
6025 {
6026 if (*buf != '\0')
6027 nwin.aka = buf;
6028 num = atoi(*av);
6029 if (num < 0 || num > MAXWIN - 1)
6030 {
6031 Msg(0, "%s: illegal screen number %d.", fn, num);
6032 num = 0;
6033 }
6034 nwin.StartAt = num;
6035 ++av;
6036 }
6037 if (av && *av)
6038 {
6039 nwin.args = av;
6040 if (!nwin.aka)
6041 nwin.aka = Filename(*av);
6042 }
6043 MakeWindow(&nwin);
6044 }
6045
6046 #ifdef COPY_PASTE
6047 /*
6048 * CompileKeys must be called before Markroutine is first used.
6049 * to initialise the keys with defaults, call CompileKeys(NULL, mark_key_tab);
6050 *
6051 * s is an ascii string in a termcap-like syntax. It looks like
6052 * "j=u:k=d:l=r:h=l: =.:" and so on...
6053 * this example rebinds the cursormovement to the keys u (up), d (down),
6054 * l (left), r (right). placing a mark will now be done with ".".
6055 */
6056 int
6057 CompileKeys(s, sl, array)
6058 char *s;
6059 int sl;
6060 unsigned char *array;
6061 {
6062 int i;
6063 unsigned char key, value;
6064
6065 if (sl == 0)
6066 {
6067 for (i = 0; i < 256; i++)
6068 array[i] = i;
6069 return 0;
6070 }
6071 debug1("CompileKeys: '%s'\n", s);
6072 while (sl)
6073 {
6074 key = *(unsigned char *)s++;
6075 if (*s != '=' || sl < 3)
6076 return -1;
6077 sl--;
6078 do
6079 {
6080 s++;
6081 sl -= 2;
6082 value = *(unsigned char *)s++;
6083 array[value] = key;
6084 }
6085 while (*s == '=' && sl >= 2);
6086 if (sl == 0)
6087 break;
6088 if (*s++ != ':')
6089 return -1;
6090 sl--;
6091 }
6092 return 0;
6093 }
6094 #endif /* COPY_PASTE */
6095
6096 /*
6097 * Asynchronous input functions
6098 */
6099
6100 #if defined(DETACH) && defined(POW_DETACH)
6101 static void
6102 pow_detach_fn(buf, len, data)
6103 char *buf;
6104 int len;
6105 char *data; /* dummy */
6106 {
6107 debug("pow_detach_fn called\n");
6108 if (len)
6109 {
6110 *buf = 0;
6111 return;
6112 }
6113 if (ktab[(int)(unsigned char)*buf].nr != RC_POW_DETACH)
6114 {
6115 if (display)
6116 write(D_userfd, "\007", 1);
6117 Msg(0, "Detach aborted.");
6118 }
6119 else
6120 Detach(D_POWER);
6121 }
6122 #endif /* POW_DETACH */
6123
6124 #ifdef COPY_PASTE
6125 static void
6126 copy_reg_fn(buf, len, data)
6127 char *buf;
6128 int len;
6129 char *data; /* dummy */
6130 {
6131 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6132
6133 if (len)
6134 {
6135 *buf = 0;
6136 return;
6137 }
6138 if (pp->buf)
6139 free(pp->buf);
6140 pp->buf = 0;
6141 pp->len = 0;
6142 if (D_user->u_plop.len)
6143 {
6144 if ((pp->buf = (char *)malloc(D_user->u_plop.len)) == NULL)
6145 {
6146 Msg(0, strnomem);
6147 return;
6148 }
6149 bcopy(D_user->u_plop.buf, pp->buf, D_user->u_plop.len);
6150 }
6151 pp->len = D_user->u_plop.len;
6152 #ifdef ENCODINGS
6153 pp->enc = D_user->u_plop.enc;
6154 #endif
6155 Msg(0, "Copied %d characters into register %c", D_user->u_plop.len, *buf);
6156 }
6157
6158 static void
6159 ins_reg_fn(buf, len, data)
6160 char *buf;
6161 int len;
6162 char *data; /* dummy */
6163 {
6164 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6165
6166 if (len)
6167 {
6168 *buf = 0;
6169 return;
6170 }
6171 if (!fore)
6172 return; /* Input() should not call us w/o fore, but you never know... */
6173 if (*buf == '.')
6174 Msg(0, "ins_reg_fn: Warning: pasting real register '.'!");
6175 if (pp->buf)
6176 {
6177 MakePaster(&fore->w_paster, pp->buf, pp->len, 0);
6178 return;
6179 }
6180 Msg(0, "Empty register.");
6181 }
6182 #endif /* COPY_PASTE */
6183
6184 static void
6185 process_fn(buf, len, data)
6186 char *buf;
6187 int len;
6188 char *data; /* dummy */
6189 {
6190 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6191
6192 if (len)
6193 {
6194 *buf = 0;
6195 return;
6196 }
6197 if (pp->buf)
6198 {
6199 ProcessInput(pp->buf, pp->len);
6200 return;
6201 }
6202 Msg(0, "Empty register.");
6203 }
6204
6205 static void
6206 confirm_fn(buf, len, data)
6207 char *buf;
6208 int len;
6209 char *data;
6210 {
6211 struct action act;
6212
6213 if (len || (*buf != 'y' && *buf != 'Y'))
6214 {
6215 *buf = 0;
6216 return;
6217 }
6218 act.nr = *(int *)data;
6219 act.args = noargs;
6220 act.argl = 0;
6221 DoAction(&act, -1);
6222 }
6223
6224 #ifdef MULTIUSER
6225 struct inputsu
6226 {
6227 struct acluser **up;
6228 char name[24];
6229 char pw1[130]; /* FreeBSD crypts to 128 bytes */
6230 char pw2[130];
6231 };
6232
6233 static void
6234 su_fin(buf, len, data)
6235 char *buf;
6236 int len;
6237 char *data;
6238 {
6239 struct inputsu *i = (struct inputsu *)data;
6240 char *p;
6241 int l;
6242
6243 if (!*i->name)
6244 { p = i->name; l = sizeof(i->name) - 1; }
6245 else if (!*i->pw1)
6246 { strcpy(p = i->pw1, "\377"); l = sizeof(i->pw1) - 1; }
6247 else
6248 { strcpy(p = i->pw2, "\377"); l = sizeof(i->pw2) - 1; }
6249 if (buf && len)
6250 strncpy(p, buf, 1 + (l < len) ? l : len);
6251 if (!*i->name)
6252 Input("Screen User: ", sizeof(i->name) - 1, INP_COOKED, su_fin, (char *)i, 0);
6253 else if (!*i->pw1)
6254 Input("User's UNIX Password: ", sizeof(i->pw1)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6255 else if (!*i->pw2)
6256 Input("User's Screen Password: ", sizeof(i->pw2)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6257 else
6258 {
6259 if ((p = DoSu(i->up, i->name, i->pw2, i->pw1)))
6260 Msg(0, "%s", p);
6261 free((char *)i);
6262 }
6263 }
6264
6265 static int
6266 InputSu(w, up, name)
6267 struct win *w;
6268 struct acluser **up;
6269 char *name;
6270 {
6271 struct inputsu *i;
6272
6273 if (!(i = (struct inputsu *)calloc(1, sizeof(struct inputsu))))
6274 return -1;
6275
6276 i->up = up;
6277 if (name && *name)
6278 su_fin(name, (int)strlen(name), (char *)i); /* can also initialise stuff */
6279 else
6280 su_fin((char *)0, 0, (char *)i);
6281 return 0;
6282 }
6283 #endif /* MULTIUSER */
6284
6285 #ifdef PASSWORD
6286
6287 static void
6288 pass1(buf, len, data)
6289 char *buf;
6290 int len;
6291 char *data;
6292 {
6293 struct acluser *u = (struct acluser *)data;
6294
6295 if (!*buf)
6296 return;
6297 ASSERT(u);
6298 if (u->u_password != NullStr)
6299 free((char *)u->u_password);
6300 u->u_password = SaveStr(buf);
6301 bzero(buf, strlen(buf));
6302 Input("Retype new password:", 100, INP_NOECHO, pass2, data, 0);
6303 }
6304
6305 static void
6306 pass2(buf, len, data)
6307 char *buf;
6308 int len;
6309 char *data;
6310 {
6311 int st;
6312 char salt[3];
6313 struct acluser *u = (struct acluser *)data;
6314
6315 ASSERT(u);
6316 if (!buf || strcmp(u->u_password, buf))
6317 {
6318 Msg(0, "[ Passwords don't match - checking turned off ]");
6319 if (u->u_password != NullStr)
6320 {
6321 bzero(u->u_password, strlen(u->u_password));
6322 free((char *)u->u_password);
6323 }
6324 u->u_password = NullStr;
6325 }
6326 else if (u->u_password[0] == '\0')
6327 {
6328 Msg(0, "[ No password - no secure ]");
6329 if (buf)
6330 bzero(buf, strlen(buf));
6331 }
6332
6333 if (u->u_password != NullStr)
6334 {
6335 for (st = 0; st < 2; st++)
6336 salt[st] = 'A' + (int)((time(0) >> 6 * st) % 26);
6337 salt[2] = 0;
6338 buf = crypt(u->u_password, salt);
6339 bzero(u->u_password, strlen(u->u_password));
6340 free((char *)u->u_password);
6341 u->u_password = SaveStr(buf);
6342 bzero(buf, strlen(buf));
6343 #ifdef COPY_PASTE
6344 if (u->u_plop.buf)
6345 UserFreeCopyBuffer(u);
6346 u->u_plop.len = strlen(u->u_password);
6347 # ifdef ENCODINGS
6348 u->u_plop.enc = 0;
6349 #endif
6350 if (!(u->u_plop.buf = SaveStr(u->u_password)))
6351 {
6352 Msg(0, strnomem);
6353 D_user->u_plop.len = 0;
6354 }
6355 else
6356 Msg(0, "[ Password moved into copybuffer ]");
6357 #else /* COPY_PASTE */
6358 Msg(0, "[ Crypted password is \"%s\" ]", u->u_password);
6359 #endif /* COPY_PASTE */
6360 }
6361 }
6362 #endif /* PASSWORD */
6363
6364 static int
6365 digraph_find(buf)
6366 const char *buf;
6367 {
6368 int i;
6369 for (i = 0; i < MAX_DIGRAPH && digraphs[i].d[0]; i++)
6370 if ((digraphs[i].d[0] == (unsigned char)buf[0] && digraphs[i].d[1] == (unsigned char)buf[1]) ||
6371 (digraphs[i].d[0] == (unsigned char)buf[1] && digraphs[i].d[1] == (unsigned char)buf[0]))
6372 break;
6373 return i;
6374 }
6375
6376 static void
6377 digraph_fn(buf, len, data)
6378 char *buf;
6379 int len;
6380 char *data; /* dummy */
6381 {
6382 int ch, i, x;
6383
6384 ch = buf[len];
6385 if (ch)
6386 {
6387 buf[len + 1] = ch; /* so we can restore it later */
6388 if (ch < ' ' || ch == '\177')
6389 return;
6390 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
6391 {
6392 if (len == 1)
6393 return;
6394 if ((ch < '0' || ch > '9') && (ch < 'a' || ch > 'f') && (ch < 'A' || ch > 'F'))
6395 {
6396 buf[len] = '\034'; /* ^] is ignored by Input() */
6397 return;
6398 }
6399 if (len == (*buf == 'U' ? 5 : 3))
6400 buf[len] = '\n';
6401 return;
6402 }
6403 if (len && *buf == '0')
6404 {
6405 if (ch < '0' || ch > '7')
6406 {
6407 buf[len] = '\034'; /* ^] is ignored by Input() */
6408 return;
6409 }
6410 if (len == 3)
6411 buf[len] = '\n';
6412 return;
6413 }
6414 if (len == 1)
6415 buf[len] = '\n';
6416 return;
6417 }
6418 if (len < 1)
6419 return;
6420 if (buf[len + 1])
6421 {
6422 buf[len] = buf[len + 1]; /* stored above */
6423 len++;
6424 }
6425 if (len < 2)
6426 return;
6427 if (!parse_input_int(buf, len, &x))
6428 {
6429 i = digraph_find(buf);
6430 if ((x = digraphs[i].value) <= 0)
6431 {
6432 Msg(0, "Unknown digraph");
6433 return;
6434 }
6435 }
6436 i = 1;
6437 *buf = x;
6438 #ifdef UTF8
6439 if (flayer->l_encoding == UTF8)
6440 i = ToUtf8(buf, x); /* buf is big enough for all UTF-8 codes */
6441 #endif
6442 while(i)
6443 LayProcess(&buf, &i);
6444 }
6445
6446 #ifdef MAPKEYS
6447 int
6448 StuffKey(i)
6449 int i;
6450 {
6451 struct action *act;
6452 int discard = 0;
6453
6454 debug1("StuffKey #%d", i);
6455 #ifdef DEBUG
6456 if (i < KMAP_KEYS)
6457 debug1(" - %s", term[i + T_CAPS].tcname);
6458 #endif
6459
6460 if (i < KMAP_KEYS && D_ESCseen)
6461 {
6462 struct action *act = &D_ESCseen[i + 256];
6463 if (act->nr != RC_ILLEGAL)
6464 {
6465 D_ESCseen = 0;
6466 DoAction(act, i + 256);
6467 return 0;
6468 }
6469 discard = 1;
6470 }
6471
6472 if (i >= T_CURSOR - T_CAPS && i < T_KEYPAD - T_CAPS && D_cursorkeys)
6473 i += T_OCAPS - T_CURSOR;
6474 else if (i >= T_KEYPAD - T_CAPS && i < T_OCAPS - T_CAPS && D_keypad)
6475 i += T_OCAPS - T_CURSOR;
6476 debug1(" - action %d\n", i);
6477 flayer = D_forecv->c_layer;
6478 fore = D_fore;
6479 act = 0;
6480 #ifdef COPY_PASTE
6481 if (InMark() || InInput() || InWList())
6482 act = i < KMAP_KEYS+KMAP_AKEYS ? &mmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].mm;
6483 #endif
6484 if ((!act || act->nr == RC_ILLEGAL) && !D_mapdefault)
6485 act = i < KMAP_KEYS+KMAP_AKEYS ? &umtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].um;
6486 if (!act || act->nr == RC_ILLEGAL)
6487 act = i < KMAP_KEYS+KMAP_AKEYS ? &dmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].dm;
6488
6489 if (discard && (!act || act->nr != RC_COMMAND))
6490 {
6491 D_ESCseen = 0;
6492 return 0;
6493 }
6494 D_mapdefault = 0;
6495
6496 if (act == 0 || act->nr == RC_ILLEGAL)
6497 return -1;
6498 DoAction(act, 0);
6499 return 0;
6500 }
6501 #endif
6502
6503
6504 static int
6505 IsOnDisplay(wi)
6506 struct win *wi;
6507 {
6508 struct canvas *cv;
6509 ASSERT(display);
6510 for (cv = D_cvlist; cv; cv = cv->c_next)
6511 if (Layer2Window(cv->c_layer) == wi)
6512 return 1;
6513 return 0;
6514 }
6515
6516 struct win *
6517 FindNiceWindow(wi, presel)
6518 struct win *wi;
6519 char *presel;
6520 {
6521 int i;
6522
6523 debug2("FindNiceWindow %d %s\n", wi ? wi->w_number : -1 , presel ? presel : "NULL");
6524 if (presel)
6525 {
6526 i = WindowByNoN(presel);
6527 if (i >= 0)
6528 wi = wtab[i];
6529 }
6530 if (!display)
6531 return wi;
6532 #ifdef MULTIUSER
6533 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6534 wi = 0;
6535 #endif
6536 if (!wi || (IsOnDisplay(wi) && !presel))
6537 {
6538 /* try to get another window */
6539 wi = 0;
6540 #ifdef MULTIUSER
6541 for (wi = windows; wi; wi = wi->w_next)
6542 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6543 break;
6544 if (!wi)
6545 for (wi = windows; wi; wi = wi->w_next)
6546 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6547 break;
6548 if (!wi)
6549 for (wi = windows; wi; wi = wi->w_next)
6550 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_READ, wi))
6551 break;
6552 if (!wi)
6553 for (wi = windows; wi; wi = wi->w_next)
6554 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_READ, wi))
6555 break;
6556 #endif
6557 if (!wi)
6558 for (wi = windows; wi; wi = wi->w_next)
6559 if (!wi->w_layer.l_cvlist)
6560 break;
6561 if (!wi)
6562 for (wi = windows; wi; wi = wi->w_next)
6563 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi))
6564 break;
6565 }
6566 #ifdef MULTIUSER
6567 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6568 wi = 0;
6569 #endif
6570 return wi;
6571 }
6572
6573 #if 0
6574
6575 /* sorted list of all commands */
6576 static struct comm **commtab;
6577 static int ncommtab;
6578
6579 void
6580 AddComms(cos, hand)
6581 struct comm *cos;
6582 void (*hand) __P((struct comm *, char **, int));
6583 {
6584 int n, i, j, r;
6585 for (n = 0; cos[n].name; n++)
6586 ;
6587 if (n == 0)
6588 return;
6589 if (commtab)
6590 commtab = (struct commt *)realloc(commtab, sizeof(*commtab) * (ncommtab + n));
6591 else
6592 commtab = (struct commt *)malloc(sizeof(*commtab) * (ncommtab + n));
6593 if (!commtab)
6594 Panic(0, strnomem);
6595 for (i = 0; i < n; i++)
6596 {
6597 for (j = 0; j < ncommtab; j++)
6598 {
6599 r = strcmp(cos[i].name, commtab[j]->name);
6600 if (r == 0)
6601 Panic(0, "Duplicate command: %s\n", cos[i].name);
6602 if (r < 0)
6603 break;
6604 }
6605 for (r = ncommtab; r > j; r--)
6606 commtab[r] = commtab[r - 1];
6607 commtab[j] = cos + i;
6608 cos[i].handler = hand;
6609 bzero(cos[i].userbits, sizeof(cos[i].userbits));
6610 ncommtab++;
6611 }
6612 }
6613
6614 struct comm *
6615 FindComm(str)
6616 char *str;
6617 {
6618 int x, m, l = 0, r = ncommtab - 1;
6619 while (l <= r)
6620 {
6621 m = (l + r) / 2;
6622 x = strcmp(str, commtab[m]->name);
6623 if (x > 0)
6624 l = m + 1;
6625 else if (x < 0)
6626 r = m - 1;
6627 else
6628 return commtab[m];
6629 }
6630 return 0;
6631 }
6632
6633 #endif
6634
6635 static int
6636 CalcSlicePercent(cv, percent)
6637 struct canvas *cv;
6638 int percent;
6639 {
6640 int w, wsum, up;
6641 if (!cv || !cv->c_slback)
6642 return percent;
6643 up = CalcSlicePercent(cv->c_slback->c_slback, percent);
6644 w = cv->c_slweight;
6645 for (cv = cv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6646 wsum += cv->c_slweight;
6647 if (wsum == 0)
6648 return 0;
6649 return (up * w) / wsum;
6650 }
6651
6652 static int
6653 ChangeCanvasSize(fcv, abs, diff, gflag, percent)
6654 struct canvas *fcv; /* make this canvas bigger */
6655 int abs; /* mode: 0:rel 1:abs 2:max */
6656 int diff; /* change this much */
6657 int gflag; /* go up if neccessary */
6658 int percent;
6659 {
6660 struct canvas *cv;
6661 int done, have, m, dir;
6662
6663 debug3("ChangeCanvasSize abs %d diff %d percent=%d\n", abs, diff, percent);
6664 if (abs == 0 && diff == 0)
6665 return 0;
6666 if (abs == 2)
6667 {
6668 if (diff == 0)
6669 fcv->c_slweight = 0;
6670 else
6671 {
6672 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6673 cv->c_slweight = 0;
6674 fcv->c_slweight = 1;
6675 cv = fcv->c_slback->c_slback;
6676 if (gflag && cv && cv->c_slback)
6677 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6678 }
6679 return diff;
6680 }
6681 if (abs)
6682 {
6683 if (diff < 0)
6684 diff = 0;
6685 if (percent && diff > percent)
6686 diff = percent;
6687 }
6688 if (percent)
6689 {
6690 int wsum, up;
6691 for (cv = fcv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6692 wsum += cv->c_slweight;
6693 if (wsum)
6694 {
6695 up = gflag ? CalcSlicePercent(fcv->c_slback->c_slback, percent) : percent;
6696 debug3("up=%d, wsum=%d percent=%d\n", up, wsum, percent);
6697 if (wsum < 1000)
6698 {
6699 int scale = wsum < 10 ? 1000 : 100;
6700 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6701 cv->c_slweight *= scale;
6702 wsum *= scale;
6703 debug1("scaled wsum to %d\n", wsum);
6704 }
6705 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6706 {
6707 if (cv->c_slweight)
6708 {
6709 cv->c_slweight = (cv->c_slweight * up) / percent;
6710 if (cv->c_slweight == 0)
6711 cv->c_slweight = 1;
6712 }
6713 debug1(" - weight %d\n", cv->c_slweight);
6714 }
6715 diff = (diff * wsum) / percent;
6716 percent = wsum;
6717 }
6718 }
6719 else
6720 {
6721 if (abs && diff == (fcv->c_slorient == SLICE_VERT ? fcv->c_ye - fcv->c_ys + 2 : fcv->c_xe - fcv->c_xs + 2))
6722 return 0;
6723 /* fix weights to real size (can't be helped, sorry) */
6724 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6725 {
6726 cv->c_slweight = cv->c_slorient == SLICE_VERT ? cv->c_ye - cv->c_ys + 2 : cv->c_xe - cv->c_xs + 2;
6727 debug1(" - weight %d\n", cv->c_slweight);
6728 }
6729 }
6730 if (abs)
6731 diff = diff - fcv->c_slweight;
6732 debug1("diff = %d\n", diff);
6733 if (diff == 0)
6734 return 0;
6735 if (diff < 0)
6736 {
6737 cv = fcv->c_slnext ? fcv->c_slnext : fcv->c_slprev;
6738 fcv->c_slweight += diff;
6739 cv->c_slweight -= diff;
6740 return diff;
6741 }
6742 done = 0;
6743 dir = 1;
6744 for (cv = fcv->c_slnext; diff > 0; cv = dir > 0 ? cv->c_slnext : cv->c_slprev)
6745 {
6746 if (!cv)
6747 {
6748 debug1("reached end, dir is %d\n", dir);
6749 if (dir == -1)
6750 break;
6751 dir = -1;
6752 cv = fcv;
6753 continue;
6754 }
6755 if (percent)
6756 m = 1;
6757 else
6758 m = cv->c_slperp ? CountCanvasPerp(cv) * 2 : 2;
6759 debug2("min is %d, have %d\n", m, cv->c_slweight);
6760 if (cv->c_slweight > m)
6761 {
6762 have = cv->c_slweight - m;
6763 if (have > diff)
6764 have = diff;
6765 debug1("subtract %d\n", have);
6766 cv->c_slweight -= have;
6767 done += have;
6768 diff -= have;
6769 }
6770 }
6771 if (diff && gflag)
6772 {
6773 /* need more room! */
6774 cv = fcv->c_slback->c_slback;
6775 if (cv && cv->c_slback)
6776 done += ChangeCanvasSize(fcv->c_slback->c_slback, 0, diff, gflag, percent);
6777 }
6778 fcv->c_slweight += done;
6779 debug1("ChangeCanvasSize returns %d\n", done);
6780 return done;
6781 }
6782
6783 struct canvas *
6784 FindCanvas(x, y)
6785 int x, y;
6786 {
6787 struct canvas *cv, *mcv = 0;
6788 int m, mm = 0;
6789
6790 for (cv = D_cvlist; cv; cv = cv->c_next)
6791 {
6792 /* ye + 1 because of caption line */
6793 if (x >= cv->c_xs && x <= cv->c_xe && y >= cv->c_ys && y <= cv->c_ye + 1)
6794 return cv;
6795 if (cv == D_forecv)
6796 continue;
6797 m = 0;
6798 if (x >= D_forecv->c_xs && x <= D_forecv->c_xe)
6799 {
6800 if (x < cv->c_xs || x > cv->c_xe)
6801 continue;
6802 if (y < D_forecv->c_ys && y < cv->c_ys)
6803 continue;
6804 if (y > D_forecv->c_ye + 1 && y > cv->c_ye + 1)
6805 continue;
6806 if (y < cv->c_ys)
6807 m = cv->c_ys - y;
6808 if (y > cv->c_ye + 1)
6809 m = y - (cv->c_ye + 1);
6810 }
6811 if (y >= D_forecv->c_ys && y <= D_forecv->c_ye + 1)
6812 {
6813 if (y < cv->c_ys || y > cv->c_ye + 1)
6814 continue;
6815 if (x < D_forecv->c_xs && x < cv->c_xs)
6816 continue;
6817 if (x > D_forecv->c_xe && x > cv->c_xe)
6818 continue;
6819 if (x < cv->c_xs)
6820 m = cv->c_xs - x;
6821 if (x > cv->c_xe)
6822 m = x - cv->c_xe;
6823 }
6824 if (m && (!mm || m < mm))
6825 {
6826 mcv = cv;
6827 mm = m;
6828 }
6829 }
6830 return mcv ? mcv : D_forecv;
6831 }
6832
6833 static void
6834 ResizeRegions(arg, flags)
6835 char *arg;
6836 int flags;
6837 {
6838 struct canvas *cv;
6839 int diff, l;
6840 int gflag = 0, abs = 0, percent = 0;
6841 int orient = 0;
6842
6843 ASSERT(display);
6844 if (!*arg)
6845 return;
6846 if (D_forecv->c_slorient == SLICE_UNKN)
6847 {
6848 Msg(0, "resize: need more than one region");
6849 return;
6850 }
6851 gflag = flags & RESIZE_FLAG_L ? 0 : 1;
6852 orient |= flags & RESIZE_FLAG_H ? SLICE_HORI : 0;
6853 orient |= flags & RESIZE_FLAG_V ? SLICE_VERT : 0;
6854 if (orient == 0)
6855 orient = D_forecv->c_slorient;
6856 l = strlen(arg);
6857 if (*arg == '=')
6858 {
6859 /* make all regions the same height */
6860 struct canvas *cv = gflag ? &D_canvas : D_forecv->c_slback;
6861 if (cv->c_slperp->c_slorient & orient)
6862 EqualizeCanvas(cv->c_slperp, gflag);
6863 /* can't use cv->c_slorient directly as it can be D_canvas */
6864 if ((cv->c_slperp->c_slorient ^ (SLICE_HORI ^ SLICE_VERT)) & orient)
6865 {
6866 if (cv->c_slback)
6867 {
6868 cv = cv->c_slback;
6869 EqualizeCanvas(cv->c_slperp, gflag);
6870 }
6871 else
6872 EqualizeCanvas(cv, gflag);
6873 }
6874 ResizeCanvas(cv);
6875 RecreateCanvasChain();
6876 RethinkDisplayViewports();
6877 ResizeLayersToCanvases();
6878 return;
6879 }
6880 if (!strcmp(arg, "min") || !strcmp(arg, "0"))
6881 {
6882 abs = 2;
6883 diff = 0;
6884 }
6885 else if (!strcmp(arg, "max") || !strcmp(arg, "_"))
6886 {
6887 abs = 2;
6888 diff = 1;
6889 }
6890 else
6891 {
6892 if (l > 0 && arg[l - 1] == '%')
6893 percent = 1000;
6894 if (*arg == '+')
6895 diff = atoi(arg + 1);
6896 else if (*arg == '-')
6897 diff = -atoi(arg + 1);
6898 else
6899 {
6900 diff = atoi(arg); /* +1 because of caption line */
6901 if (diff < 0)
6902 diff = 0;
6903 abs = diff == 0 ? 2 : 1;
6904 }
6905 }
6906 if (!abs && !diff)
6907 return;
6908 if (percent)
6909 diff = diff * percent / 100;
6910 cv = D_forecv;
6911 if (cv->c_slorient & orient)
6912 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6913 if (cv->c_slback->c_slorient & orient)
6914 ChangeCanvasSize(cv->c_slback, abs, diff, gflag, percent);
6915
6916 ResizeCanvas(&D_canvas);
6917 RecreateCanvasChain();
6918 RethinkDisplayViewports();
6919 ResizeLayersToCanvases();
6920 return;
6921
6922 #if 0
6923
6924 if (siz + diff < 1)
6925 diff = 1 - siz;
6926 if (siz + diff > dsize - (nreg - 1) * 2 - 1)
6927 diff = dsize - (nreg - 1) * 2 - 1 - siz;
6928 if (diff == 0 || siz + diff < 1)
6929 return;
6930
6931 if (diff < 0)
6932 {
6933 if (D_forecv->c_next)
6934 {
6935 D_forecv->c_ye += diff;
6936 D_forecv->c_next->c_ys += diff;
6937 D_forecv->c_next->c_yoff += diff;
6938 }
6939 else
6940 {
6941 for (cv = D_cvlist; cv; cv = cv->c_next)
6942 if (cv->c_next == D_forecv)
6943 break;
6944 ASSERT(cv);
6945 cv->c_ye -= diff;
6946 D_forecv->c_ys -= diff;
6947 D_forecv->c_yoff -= diff;
6948 }
6949 }
6950 else
6951 {
6952 int s, i = 0, found = 0, di = diff, d2;
6953 s = dsize - (nreg - 1) * 2 - 1 - siz;
6954 for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next)
6955 {
6956 if (cv == D_forecv)
6957 {
6958 cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff;
6959 cv->c_yoff -= cv->c_ys - i;
6960 cv->c_ys = i;
6961 found = 1;
6962 continue;
6963 }
6964 s -= cv->c_ye - cv->c_ys;
6965 if (!found)
6966 {
6967 if (s >= di)
6968 continue;
6969 d2 = di - s;
6970 }
6971 else
6972 d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di;
6973 di -= d2;
6974 cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2;
6975 cv->c_yoff -= cv->c_ys - i;
6976 cv->c_ys = i;
6977 }
6978 }
6979 RethinkDisplayViewports();
6980 ResizeLayersToCanvases();
6981 #endif
6982 }
6983
6984 static void
6985 ResizeFin(buf, len, data)
6986 char *buf;
6987 int len;
6988 char *data;
6989 {
6990 int ch;
6991 int flags = *(int *)data;
6992 ch = ((unsigned char *)buf)[len];
6993 if (ch == 0)
6994 {
6995 ResizeRegions(buf, flags);
6996 return;
6997 }
6998 if (ch == 'h')
6999 flags ^= RESIZE_FLAG_H;
7000 else if (ch == 'v')
7001 flags ^= RESIZE_FLAG_V;
7002 else if (ch == 'b')
7003 flags |= RESIZE_FLAG_H|RESIZE_FLAG_V;
7004 else if (ch == 'p')
7005 flags ^= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
7006 else if (ch == 'l')
7007 flags ^= RESIZE_FLAG_L;
7008 else
7009 return;
7010 inp_setprompt(resizeprompts[flags], NULL);
7011 *(int *)data = flags;
7012 buf[len] = '\034';
7013 }
7014
7015 void
7016 SetForeCanvas(d, cv)
7017 struct display *d;
7018 struct canvas *cv;
7019 {
7020 struct display *odisplay = display;
7021 if (d->d_forecv == cv)
7022 return;
7023
7024 display = d;
7025 D_forecv = cv;
7026 if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) ||
7027 (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight)))
7028 {
7029 ResizeCanvas(&D_canvas);
7030 RecreateCanvasChain();
7031 RethinkDisplayViewports();
7032 ResizeLayersToCanvases(); /* redisplays */
7033 }
7034 fore = D_fore = Layer2Window(D_forecv->c_layer);
7035 if (D_other == fore)
7036 D_other = 0;
7037 flayer = D_forecv->c_layer;
7038 #ifdef RXVT_OSC
7039 if (D_xtermosc[2] || D_xtermosc[3])
7040 {
7041 Activate(-1);
7042 }
7043 else
7044 #endif
7045 {
7046 RefreshHStatus();
7047 #ifdef RXVT_OSC
7048 RefreshXtermOSC();
7049 #endif
7050 flayer = D_forecv->c_layer;
7051 CV_CALL(D_forecv, LayRestore();LaySetCursor());
7052 WindowChanged(0, 'F');
7053 }
7054
7055 display = odisplay;
7056 }
7057
7058 #ifdef RXVT_OSC
7059 void
7060 RefreshXtermOSC()
7061 {
7062 int i;
7063 struct win *p;
7064
7065 p = Layer2Window(D_forecv->c_layer);
7066 for (i = 3; i >=0; i--)
7067 SetXtermOSC(i, p ? p->w_xtermosc[i] : 0);
7068 }
7069 #endif
7070
7071 int
7072 ParseAttrColor(s1, s2, msgok)
7073 char *s1, *s2;
7074 int msgok;
7075 {
7076 int i, n;
7077 char *s, *ss;
7078 int r = 0;
7079
7080 s = s1;
7081 while (*s == ' ')
7082 s++;
7083 ss = s;
7084 while (*ss && *ss != ' ')
7085 ss++;
7086 while (*ss == ' ')
7087 ss++;
7088 if (*s && (s2 || *ss || !((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || *s == '.')))
7089 {
7090 int mode = 0, n = 0;
7091 if (*s == '+')
7092 {
7093 mode = 1;
7094 s++;
7095 }
7096 else if (*s == '-')
7097 {
7098 mode = -1;
7099 s++;
7100 }
7101 else if (*s == '!')
7102 {
7103 mode = 2;
7104 s++;
7105 }
7106 else if (*s == '=')
7107 s++;
7108 if (*s >= '0' && *s <= '9')
7109 {
7110 n = *s++ - '0';
7111 if (*s >= '0' && *s <= '9')
7112 n = n * 16 + (*s++ - '0');
7113 else if (*s >= 'a' && *s <= 'f')
7114 n = n * 16 + (*s++ - ('a' - 10));
7115 else if (*s >= 'A' && *s <= 'F')
7116 n = n * 16 + (*s++ - ('A' - 10));
7117 else if (*s && *s != ' ')
7118 {
7119 if (msgok)
7120 Msg(0, "Illegal attribute hexchar '%c'", *s);
7121 return -1;
7122 }
7123 }
7124 else
7125 {
7126 while (*s && *s != ' ')
7127 {
7128 if (*s == 'd')
7129 n |= A_DI;
7130 else if (*s == 'u')
7131 n |= A_US;
7132 else if (*s == 'b')
7133 n |= A_BD;
7134 else if (*s == 'r')
7135 n |= A_RV;
7136 else if (*s == 's')
7137 n |= A_SO;
7138 else if (*s == 'B')
7139 n |= A_BL;
7140 else
7141 {
7142 if (msgok)
7143 Msg(0, "Illegal attribute specifier '%c'", *s);
7144 return -1;
7145 }
7146 s++;
7147 }
7148 }
7149 if (*s && *s != ' ')
7150 {
7151 if (msgok)
7152 Msg(0, "junk after attribute description: '%c'", *s);
7153 return -1;
7154 }
7155 if (mode == -1)
7156 r = n << 8 | n;
7157 else if (mode == 1)
7158 r = n << 8;
7159 else if (mode == 2)
7160 r = n;
7161 else if (mode == 0)
7162 r = 0xffff ^ n;
7163 }
7164 while (*s && *s == ' ')
7165 s++;
7166
7167 if (s2)
7168 {
7169 if (*s)
7170 {
7171 if (msgok)
7172 Msg(0, "junk after description: '%c'", *s);
7173 return -1;
7174 }
7175 s = s2;
7176 while (*s && *s == ' ')
7177 s++;
7178 }
7179
7180 #ifdef COLOR
7181 if (*s)
7182 {
7183 static char costr[] = "krgybmcw d i.01234567 9 f FKRGYBMCW I ";
7184 int numco = 0, j;
7185
7186 n = 0;
7187 if (*s == '.')
7188 {
7189 numco++;
7190 n = 0x0f;
7191 s++;
7192 }
7193 for (j = 0; j < 2 && *s && *s != ' '; j++)
7194 {
7195 for (i = 0; costr[i]; i++)
7196 if (*s == costr[i])
7197 break;
7198 if (!costr[i])
7199 {
7200 if (msgok)
7201 Msg(0, "illegal color descriptor: '%c'", *s);
7202 return -1;
7203 }
7204 numco++;
7205 n = n << 4 | (i & 15);
7206 #ifdef COLORS16
7207 if (i >= 48)
7208 n = (n & 0x20ff) | 0x200;
7209 #endif
7210 s++;
7211 }
7212 if ((n & 0xf00) == 0xf00)
7213 n ^= 0xf00; /* clear superflous bits */
7214 #ifdef COLORS16
7215 if (n & 0x2000)
7216 n ^= 0x2400; /* shift bit into right position */
7217 #endif
7218 if (numco == 1)
7219 n |= 0xf0; /* don't change bg color */
7220 if (numco != 2 && n != 0xff)
7221 n |= 0x100; /* special invert mode */
7222 if (*s && *s != ' ')
7223 {
7224 if (msgok)
7225 Msg(0, "junk after color description: '%c'", *s);
7226 return -1;
7227 }
7228 n ^= 0xff;
7229 r |= n << 16;
7230 }
7231 #endif
7232
7233 while (*s && *s == ' ')
7234 s++;
7235 if (*s)
7236 {
7237 if (msgok)
7238 Msg(0, "junk after description: '%c'", *s);
7239 return -1;
7240 }
7241 debug1("ParseAttrColor %06x\n", r);
7242 return r;
7243 }
7244
7245 /*
7246 * Color coding:
7247 * 0-7 normal colors
7248 * 9 default color
7249 * e just set intensity
7250 * f don't change anything
7251 * Intensity is encoded into bits 17(fg) and 18(bg).
7252 */
7253 void
7254 ApplyAttrColor(i, mc)
7255 int i;
7256 struct mchar *mc;
7257 {
7258 debug1("ApplyAttrColor %06x\n", i);
7259 mc->attr |= i >> 8 & 255;
7260 mc->attr ^= i & 255;
7261 #ifdef COLOR
7262 i = (i >> 16) ^ 0xff;
7263 if ((i & 0x100) != 0)
7264 {
7265 i &= 0xeff;
7266 if (mc->attr & (A_SO|A_RV))
7267 # ifdef COLORS16
7268 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) | ((i & 0x200) << 1) | ((i & 0x400) >> 1);
7269 # else
7270 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4);
7271 # endif
7272 }
7273 # ifdef COLORS16
7274 if ((i & 0x0f) != 0x0f)
7275 mc->attr = (mc->attr & 0xbf) | ((i >> 3) & 0x40);
7276 if ((i & 0xf0) != 0xf0)
7277 mc->attr = (mc->attr & 0x7f) | ((i >> 3) & 0x80);
7278 # endif
7279 mc->color = 0x99 ^ mc->color;
7280 if ((i & 0x0e) == 0x0e)
7281 i = (i & 0xf0) | (mc->color & 0x0f);
7282 if ((i & 0xe0) == 0xe0)
7283 i = (i & 0x0f) | (mc->color & 0xf0);
7284 mc->color = 0x99 ^ i;
7285 debug2("ApplyAttrColor - %02x %02x\n", mc->attr, i);
7286 #endif
7287 }
Lua scripting support for GNU Screen