Debian Codegraph @

xjove/xjove.c

raw
1 /*
2 * Copyright (C) 1986 Free Software Foundation, Inc.
3 * Copyright (C) 1991-1999 C.H.Lindsey, University of Manchester
4 *
5 * This file is derived from the program emacstool, which is itself part of the
6 * GNU Emacs system.
7 *
8 * In the same way as GNU Emacs itself, this file is distributed in the hope
9 * that it will be useful, but without any warranty. No author or
10 * distributor accepts responsibility to anyone for the consequences of using
11 * it or for whether it serves any particular purpose or works at all, unless
12 * he says so in writing.
13 *
14 * Everyone is granted permission to copy, modify and redistribute this file,
15 * but only under the conditions described in the document "GNU Emacs copying
16 * permission notice". A copy of that document is distributed along with
17 * GNU Emacs and other GNU Products so that you can know how you may
18 * redistribute it all. In particular and among other things, this copyright
19 * notice must be preserved on all copies of this file and of files derived
20 * from it.
21 *
22 *
23 * For Jove in SunView/Sun-Windows: (supported by Sun Unix v3.2) Insert a
24 * notifier filter-function to convert all useful input to "key" sequences
25 * that jove can understand. See: Xjove(1).
26 *
27 * Author (of Jovetool/Xjove): C. H. Lindsey, University of Manchester
28 * <[email protected]>
29 * Author (of Emacstool): Jeff Peck, Sun Microsystems, Inc. <[email protected]>
30 *
31 * Original Idea: Ian Batten
32 *
33 */
34
35 #include <xview/defaults.h>
36 #include <xview/xview.h>
37 #include <xview/tty.h>
38 #include <xview/ttysw.h> /* is this missing on some systems? */
39 #include <xview/termsw.h>
40 #include <xview/cursor.h>
41 #include <xview/font.h>
42 #include <X11/Xlib.h>
43 #include <X11/keysym.h>
44 #include <X11/Sunkeysym.h> /* for Suns only */
45 #include <stdio.h>
46 #include <string.h>
47 #include <sys/file.h>
48 #include <stdlib.h>
49 #include <unistd.h> /* is this missing on some systems? */
50 #include <fcntl.h>
51 #include <termios.h>
52
53 #include "exts.h"
54 #include "mousemsg.h"
55
56 #define BUFFER_SIZE 256 /* Size of all the buffers */
57
58 #define CLICK 400 /* max time in ms for click, or gap between
59 * double click */
60
61 /* define WANT_CAPS_LOCK to make f-key T1 (aka F1) behave as CapsLock */
62 /* #define WANT_CAPS_LOCK */
63
64 private const char mouse_prefix[] = "\030m"; /* ^x m */
65 private const char key_prefix[] = "\033["; /* ESC-[ */
66
67 private char *jove_name = "jove"; /* default run command */
68 private char buffer[BUFFER_SIZE]; /* send to ttysw_input */
69 private const char title[] = "XJove - "; /* initial title */
70
71 private Frame frame; /* Base frame for system */
72 Tty ttysw; /* Where jove is */
73 private Tty ttyview;
74 private int font_width, font_height; /* For translating pixels to
75 * chars */
76 private int left_margin, right_margin;
77
78 private FILE *console = NULL; /* for debugging: setenv DEBUGJOVETOOL */
79
80 private Icon frame_icon;
81 /* make an icon_image */
82 private unsigned short default_image[] =
83 {
84 #include "jove.icon"
85 };
86 mpr_static_static(icon_image, 64, 64, 1, default_image);
87
88 private Xv_Cursor current_cursor, jove_cursor, cut_cursor, copy_cursor, paste_cursor, default_cursor;
89
90 private unsigned short cursor_image[] = {
91 #include "jove.cursor"
92 };
93 mpr_static_static(cursor_pix, 16, 16, 1, cursor_image);
94
95 private unsigned short cut_image[] = {
96 #include "cut.cursor"
97 };
98 mpr_static_static(cut_pix, 16, 16, 1, cut_image);
99
100 private unsigned short copy_image[] = {
101 #include "copy.cursor"
102 };
103 mpr_static_static(copy_pix, 16, 16, 1, copy_image);
104
105 private unsigned short paste_image[] = {
106 #include "paste.cursor"
107 };
108 mpr_static_static(paste_pix, 16, 16, 1, paste_image);
109
110 Xv_Font font;
111
112
113
114 private void
115 set_cursor(cursor)
116 Xv_Cursor cursor;
117 {
118 if (current_cursor != cursor) {
119 xv_set(ttyview, WIN_CURSOR, cursor, 0);
120 current_cursor = cursor;
121 }
122 }
123
124
125 /*
126 * button_value: encode mouse event into an xjove event code (the return
127 * value) and a button state (stored in last_but). If the event ought to be
128 * ignored due to error, -1 is returned in place of the event code. If it is
129 * to be ignored silently, -2 is returned.
130 */
131 private int
132 last_but = JT_UPEVENT, /* button state */
133 event_shift, /* shift state */
134 next_kdb_event_should_be_up;
135 private char
136 last_event_string[7]; /* string from last F-key down event,
137 * 6 being the longest string
138 * expected from an F-key */
139
140 private int
141 button_value(event)
142 Event *event;
143 {
144 static struct timeval
145 mouse_time = {0, 0},
146 prev_mouse_time;
147
148 static int multiclick_state = 0;
149
150 int
151 this_but = event_shift, /* button state, after this
152 * event */
153 mouse_code; /* event code for this event */
154
155 switch (event_id(event)) {
156 case LOC_DRAG:
157 if (last_but & JT_UPEVENT)
158 return -1;
159 else if (multiclick_state)
160 return -2;
161 last_but |= JT_DRAGEVENT;
162 {
163 /*
164 * Generate event code for leftmost depressed button.
165 * Currently, only one bit will be on, so this is
166 * overkill.
167 */
168 static short DragCode[8] = {
169 -1, JTEC_LEFT, JTEC_MIDDLE, JTEC_LEFT,
170 JTEC_RIGHT, JTEC_LEFT, JTEC_MIDDLE, JTEC_LEFT};
171
172 return DragCode[last_but & JT_BUTMASK] + JTEC_DRAG;
173 }
174 case MS_LEFT:
175 this_but |= JT_LEFT;
176 mouse_code = JTEC_LEFT;
177 break;
178 case MS_MIDDLE:
179 this_but |= JT_MIDDLE;
180 mouse_code = JTEC_MIDDLE;
181 break;
182 case MS_RIGHT:
183 this_but |= JT_RIGHT;
184 mouse_code = JTEC_RIGHT;
185 break;
186 default:
187 return -1;
188 }
189
190 /*
191 * Clicking too fast can sometimes beat the system. Also, a user
192 * might manage to get two buttons down at the same time. The
193 * following tests detect such situations. Note that up events after
194 * JT_RIGHT are absorbed by the menu software.
195 */
196 if (event_is_up(event)) {
197 /* ignore up not following a down or up of a different button */
198 if ((last_but & (JT_UPEVENT | JT_RIGHT)) == JT_UPEVENT
199 || ((last_but ^ this_but) & JT_BUTMASK) != 0)
200 return -1;
201 this_but |= JT_UPEVENT;
202 mouse_code += JTEC_UP;
203 } else if (event_is_down(event)) {
204 if ((last_but & (JT_UPEVENT | JT_RIGHT)) == 0) {
205 /* down event not preceded by an up or right event */
206 return -1;
207 }
208 } else { /* drag event */
209 if ((last_but & (JT_DOWNEVENT | JT_DRAGEVENT)) == 0) {
210 /* drag event not preceded by a down or drag event */
211 return -1;
212 }
213 }
214 /*
215 * The only way to get back into sync is to supply whatever up or
216 * down event it was waiting for. Thus jove should always see a
217 * consistent picture
218 */
219
220 /*-- Detect and encode multi-clicks.
221 *
222 * - a multiclick is a train of alternating mouse-down and mouse-up events
223 * - the first must be a mouse-down
224 * - Each mouse up and down must be of the same button
225 * - each of which happens within CLICK milliseconds of its predecessor
226 * - Drags are not taken into consideration.
227 */
228
229 prev_mouse_time = mouse_time;
230 mouse_time = event_time(event);
231
232 multiclick_state += 1;
233 if (((multiclick_state & 1) == 0) == ((this_but & JT_UPEVENT) == 0)
234 && ((last_but ^ this_but) & JT_BUTMASK) == 0
235 && (mouse_time.tv_sec - prev_mouse_time.tv_sec) * 1000
236 + (mouse_time.tv_usec - prev_mouse_time.tv_usec) / 1000 <= CLICK) {
237 switch (multiclick_state) {
238 case 1: /* first up */
239 break;
240 case 2: /* second down */
241 mouse_code += JTEC_CLICK2;
242 /* FALLTHROUGH */
243 case 3: /* second up */
244 this_but |= JT_CLICK2;
245 break;
246 case 4: /* third down */
247 mouse_code += JTEC_CLICK3;
248 /* FALLTHROUGH */
249 case 5: /* third up */
250 this_but |= JT_CLICK3;
251 break;
252 default: /* too many multi-clicks */
253 multiclick_state = 0;
254 break;
255 }
256 } else {
257 multiclick_state = 0;
258 }
259
260 last_but = this_but;
261 return mouse_code;
262 }
263
264
265 /*
266 * Filter function to translate selected input events for jove Mouse button
267 * events become ^XmC(button-state x-col y-line font-width) . - C is an
268 * eventcode (explained in mousemsg.h) - button-state is as described
269 * mousemsg.h for this_but - x-col is horizontal column, in pixels (for
270 * smooth scrollbar working) - y-col is height, in characters - font-width
271 * allows conversion of x-col to characters Sun function keys (left, top, and
272 * right) are converted to the ANSI sequence ESC [ P z, where P is a number
273 * above 192
274 */
275
276 private Notify_value
277 input_event_filter_function(window, event, arg, type)
278 Xv_Window window;
279 Event *event;
280 Notify_arg arg;
281 Notify_event_type type;
282 {
283 int id = event_id(event);
284 int mouse_code = -3; /* not -1 and not -2 and not
285 * >=0 */
286 int fkey;
287
288 event_shift &= ~JT_CSMASK;
289 if (event_shift_is_down(event))
290 event_shift |= JT_SHIFT;
291 if (event_ctrl_is_down(event))
292 event_shift |= JT_CONTROL;
293 /*
294 * Under Xview (but not SunView) the answers to the above queries do
295 * not reflect the effect of the current event!
296 */
297 {
298 int delta = 0;
299
300 switch (event_action(event)) {
301 case SHIFT_LEFT:
302 case SHIFT_RIGHT:
303 delta = JT_SHIFT;
304 break;
305 case SHIFT_CTRL:
306 delta = JT_CONTROL;
307 break;
308 case ACTION_PASTE:
309 delta = JT_PASTE;
310 break;
311 case ACTION_CUT:
312 delta = JT_CUT;
313 break;
314 }
315 if (event_is_up(event))
316 event_shift &= ~delta;
317 else
318 event_shift |= delta;
319 }
320
321 if (console != NULL) {
322 fprintf(console, "Ttyview Event %d", id);
323 if (event_shift != 0)
324 fprintf(console, "; shift %d", event_shift);
325 if (event_is_up(event))
326 fprintf(console, "; up");
327 if (event_is_button(event))
328 fprintf(console, "; button %d", id - BUT(0));
329 fprintf(console, "\n");
330 }
331 switch (id) {
332 case LOC_DRAG:
333 mouse_code = button_value(event);
334 /* no need to set cursor */
335 break;
336 case MS_LEFT:
337 case MS_MIDDLE:
338 case MS_RIGHT:
339 mouse_code = button_value(event);
340 if (last_but & JT_PASTEMASK)
341 last_event_string[0] = 0;
342 /*
343 * We do not wish to see Left keys (esp. PASTE & CUT)
344 * associated with buttons
345 */
346 /* FALLTHROUGH */
347 case SHIFT_LEFT:
348 case SHIFT_RIGHT:
349 case SHIFT_CTRL:
350 /* set cursor appropriately */
351 if (event_shift == JT_SHIFT) {
352 set_cursor(default_cursor);
353 } else {
354 switch (event_shift | (last_but & (JT_UPEVENT | JT_BUTMASK))) {
355 case JT_SHIFT | JT_CONTROL | JT_MIDDLE:
356 set_cursor(cut_cursor);
357 break;
358 case JT_CONTROL | JT_MIDDLE:
359 set_cursor(copy_cursor);
360 break;
361 case JT_CONTROL | JT_LEFT:
362 set_cursor(paste_cursor);
363 break;
364 default:
365 set_cursor(jove_cursor);
366 break;
367 }
368 }
369 break;
370 case KEY_LEFT(5): /* EXPOSE or FRONT key */
371 case KEY_LEFT(7): /* OPEN key */
372 /*
373 * UP L5 & L7 are Expose & Open, let them pass to SunView.
374 * Apparently it only cares about up events. Actually, the
375 * down event never gets this far, but the up event seems to
376 * be needed to force a refresh.
377 */
378 return event_is_up(event)
379 ? notify_next_event_func(window, (Notify_event) event, arg, type)
380 : NOTIFY_IGNORED;
381 }
382
383 /* Treat shifted events as normal Shelltool events. */
384 if (event_shift == JT_SHIFT && id >= ISO_LAST) {
385 Notify_value result;
386
387 /* Translate well-known left keys. */
388 switch (id) {
389 case KEY_LEFT(6):
390 event->action = ACTION_COPY;
391 break;
392 case KEY_LEFT(8):
393 event->action = ACTION_PASTE;
394 break;
395 case KEY_LEFT(10):
396 event->action = ACTION_COPY; /* CUT is censored */
397 break;
398 }
399
400 event_shiftmask(event) &= ~SHIFTMASK; /* get rid of shift */
401 event_set_string(event, NULL); /* later versions of xview
402 * seem to output this string
403 * even when they have already
404 * interpreted the event as a
405 * copy/paste/cut
406 */
407
408 result = notify_next_event_func(window, (Notify_event) event, arg, type);
409 return result;
410 }
411 /* do Mouse Button events */
412
413 if (mouse_code >= 0) {
414 int
415 this_x = event_x(event) - left_margin, this_y = event_y(event) / font_height;
416 static int last_x, last_y;
417
418 if (last_but & JT_RIGHT) {
419 /*
420 * ??? avoid passing up-event, if we catch it --
421 * would cause deadlock.
422 */
423 if (last_but == JT_RIGHT)
424 menu_show(main_menu, window, event, 0);
425 } else {
426 if (this_x == last_x && this_y == last_y) {
427 if (id == LOC_DRAG)
428 return NOTIFY_IGNORED;
429 sprintf(buffer, "%s%d(%d)\015",
430 mouse_prefix, mouse_code, last_but);
431 } else {
432 sprintf(buffer, "%s%d(%d %d %d %d)\015",
433 mouse_prefix, mouse_code, last_but,
434 this_x, this_y, font_width);
435 last_x = this_x;
436 last_y = this_y;
437 }
438 ttysw_input(ttysw, buffer, strlen(buffer));
439 }
440 return NOTIFY_IGNORED;
441 } else if (mouse_code == -1) {
442 ttysw_output(ttysw, "\007", 1); /* beep */
443 return NOTIFY_IGNORED;
444 } else if (mouse_code == -2) {
445 return NOTIFY_IGNORED;
446 }
447 if (next_kdb_event_should_be_up && event_is_down(event)
448 && event_is_iso(event)) {
449 ttysw_output(ttysw, "\007", 1); /* beep */
450 return NOTIFY_IGNORED;
451 }
452 next_kdb_event_should_be_up = 0;
453
454 if (event_is_string(event) /* it has been rebound with
455 * XRebindKeysym */
456 ||event_is_key_left(event)) { /* For some reason, up events
457 * of PASTE and CUT do not
458 * appear as string events,
459 * but they must be caught
460 * here */
461 if (event_is_down(event)) {
462 if (event_is_string(event)) {
463 strcpy(last_event_string, event_string(event));
464 /*
465 * because XView does not seem to provide
466 * these strings on the up event
467 */
468 } else {
469 last_event_string[0] = '\0';
470 /*
471 * Sometimes, even the down event of PASTE is
472 * not a string, as when Caps Lock is down.
473 * Forget it!
474 */
475 }
476 }
477 if (!event_button_is_down(event)) {
478 /*
479 * we don't want any function keys (esp PASTE & CUT)
480 * seen when a button is down
481 */
482 if (event_action(event) == ACTION_PASTE
483 || event_action(event) == ACTION_CUT) {
484 if (event_is_down(event)) {
485 /*
486 * we see PASTE and CUT when they
487 * come up
488 */
489 next_kdb_event_should_be_up = 1;
490 return NOTIFY_IGNORED;
491 }
492 } else if (event_is_up(event)) {
493 /* we see other F-keys when they go down */
494 return NOTIFY_IGNORED;
495 }
496 ttysw_input(ttysw, last_event_string, strlen(last_event_string));
497 }
498 return NOTIFY_IGNORED;
499 }
500 if (ISO_FIRST <= id && id <= ISO_LAST) {
501 /*
502 * Force bit 8 if meta key is down. But it will only be
503 * noticed by the controlled process if it does a stty
504 * -istrip, or equivalent.
505 */
506 if (event_shiftmask(event) & META_SHIFT_MASK)
507 event->ie_code |= META_KEY_MASK;
508 }
509 /* If we get here, pass event off to next handler */
510 return notify_next_event_func(window, (Notify_event) event, arg, type);
511 }
512
513 private Notify_value
514 tty_event_filter_function(window, event, arg, type)
515 Xv_Window window;
516 Event *event;
517 Notify_arg arg;
518 Notify_event_type type;
519 {
520 if (console != NULL)
521 fprintf(console, "Ttysw Event: %d\n", event_id(event));
522
523 if (event_id(event) == KBD_USE) {
524 win_set_kbd_focus(ttyview, xv_get(ttyview, XV_XID));
525 return NOTIFY_IGNORED;
526 } else {
527 return notify_next_event_func(window, (Notify_event) event, arg, type);
528 }
529 }
530
531
532 void
533 bind_key(ksym, string)
534 KeySym ksym;
535 char *string;
536 {
537 Display *dpy;
538 static KeySym shift_list[] =
539 {XK_Shift_L, XK_Control_L, XK_Meta_L, XK_Alt_L, XK_Mode_switch};
540 int i;
541
542 dpy = (Display *) xv_get(frame, XV_DISPLAY);
543 XRebindKeysym(dpy, ksym, NULL, 0, (unsigned char *) string, strlen(string));
544 for (i = 0; i != sizeof(shift_list) / sizeof(*shift_list); i++)
545 XRebindKeysym(dpy, ksym, &shift_list[i], 1, (unsigned char *) string, strlen(string));
546 }
547
548 void
549 bind_function_keys(first, count, number)
550 KeySym first;
551 unsigned int count, number;
552 {
553 int i;
554 char buffer[6];
555
556 for (i = 0; i < count; i++) {
557 sprintf(buffer, "%s%3dz", key_prefix, number + i);
558 bind_key(first + i, buffer);
559 }
560 }
561
562 int
563 main(argc, argv)
564 int argc;
565 char **argv;
566 {
567 int error_code; /* Error codes */
568 int forking;
569 int argstart = 1;
570 char *debug;
571 int child_argc, i;
572 char **child_argv;
573 char *icon_label;
574 int tty_fd;
575 struct termios tty;
576
577 xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, 0);
578
579 if ((debug = getenv("DEBUGJOVETOOL")) != NULL) {
580 /*
581 * DEBUGJOVETOOL specifies the file or device to receive
582 * debugging output, if any. The null name signifies stderr.
583 */
584 console = *debug == '\0' ? stderr : fopen(debug, "w");
585 forking = 0;
586 } else if (!isatty(0)) {
587 forking = 0;
588 } else {
589 forking = defaults_get_boolean("xjove.forking", "Xjove.Forking", 0);
590 }
591
592 if (argc>1 && !strcmp("-nf", argv[1])) {
593 forking = 0;
594 argstart = 2;
595 } else if (argc>1 && !strcmp("-f", argv[1])) {
596 forking = 1;
597 argstart = 2;
598 }
599
600 if (forking) {
601 switch (fork()) {
602 case -1:
603 fprintf(stderr, "fork failed");
604 exit(1);
605 /* NOTREACHED */
606 case 0: /* the child */
607 #ifdef SYSVR4
608 setsid(); /* so it doesn't get killed when
609 * parent dies */
610 #else
611 setpgid(0, 0); /* For some reason, setsid() hinders
612 * passing of SIGWINCH events to the
613 * controlled process in SUNOS4 */
614 #endif
615 break;
616 default: /* the parent */
617 exit(0);
618 /* NOTREACHED */
619 }
620 }
621
622 putenv("IN_JOVETOOL=t");/* notify subprocess that it is in jovetool */
623
624 font = (Xv_font) xv_find(ttysw, FONT, FONT_NAME,
625 defaults_get_string("xjove.font.name", "Xjove.Font.Name", "lucidasanstypewriter-12"),
626 0);
627
628 child_argv = (char **) malloc((argc + 1) * sizeof(char *));
629 if (!(child_argv[0] = (char *) getenv("JOVETOOL"))) /* Set jove command name */
630 child_argv[0] = jove_name;
631 for (child_argc = 1, i = argstart; i < argc; i++) {
632 if (!strcmp("-rc", argv[i])) {
633 child_argv[0] = argv[++i];
634 child_argc = 1;
635 } else {
636 child_argv[child_argc++] = argv[i];
637 }
638 }
639 child_argv[child_argc] = NULL;
640
641 /*
642 * choose a "sensible" parameter to put in the icon label, preferably
643 * the file to be edited
644 */
645 icon_label = child_argv[0];
646 for (i = 1; i < child_argc; i++)
647 if (child_argv[i][0] != '-')
648 icon_label = child_argv[i];
649 frame_icon = icon_create(XV_LABEL, icon_label,
650 ICON_IMAGE, &icon_image,
651 0);
652
653 /* construct the title of the window */
654 strcpy(buffer, title);
655 strncat(buffer, child_argv[0], /* append run command name */
656 (BUFFER_SIZE - (strlen(buffer)) - (strlen(argv[0]))) - 1);
657
658 /* Build a frame to run in */
659 frame = xv_create(XV_NULL, FRAME,
660 XV_LABEL, buffer,
661 FRAME_ICON, frame_icon,
662 0);
663 /* construct the command parameters to be shown to Save Workspace */
664 buffer[0] = '\0';
665 for (i = 1; i < argc; i++)
666 sprintf(&buffer[strlen(buffer)], "%s ", argv[i]);
667 xv_set(frame, WIN_CMD_LINE, buffer, 0);
668
669 /* Create a tty with jove in it */
670 ttysw = xv_create(frame, TERMSW,
671 TTY_ARGV, TTY_ARGV_DO_NOT_FORK,
672 XV_LEFT_MARGIN, defaults_get_integer(
673 "text.margin.left", "Text.Margin.Left", 4),
674 XV_RIGHT_MARGIN, defaults_get_integer(
675 "text.margin.right", "Text.Margin.Right", 0),
676 /* 0 because jove never uses the last column anyway */
677 TEXTSW_FONT, font,
678 0);
679
680 ttyview = xv_get(ttysw, OPENWIN_NTH_VIEW, 0);
681 left_margin = xv_get(ttysw, XV_LEFT_MARGIN);
682 right_margin = xv_get(ttysw, XV_RIGHT_MARGIN);
683 font_height = (int) xv_get(ttysw, WIN_ROW_HEIGHT);
684 font_width = (int) xv_get(ttysw, WIN_COLUMN_WIDTH);
685
686 tty_fd = (int) xv_get(ttysw, TTY_TTY_FD);
687 tcgetattr(tty_fd, &tty);
688 tty.c_iflag &= ~ISTRIP;
689 tcsetattr(tty_fd, TCSANOW, &tty);
690 /* "TTY_ARGV, child_argv" must not be set going before that tcsetattr */
691
692 xv_set(ttysw, TERMSW_MODE, TTYSW_MODE_TYPE,
693 TTY_QUIT_ON_CHILD_DEATH, TRUE,
694 TTY_ARGV, child_argv,
695 OPENWIN_ADJUST_FOR_VERTICAL_SCROLLBAR, 0,
696 XV_WIDTH, defaults_get_integer(
697 "window.columns", "Window.Columns", 80) * font_width
698 + left_margin + right_margin + 2,
699 /*
700 * WIN_COLUMNS was not used here because it gets confused by the
701 * non-existent scrollbar; the '+ 2' is one pixel for each border
702 */
703 WIN_ROWS, defaults_get_integer(
704 "window.rows", "Window.Rows", 35),
705 0);
706
707
708 xv_set(ttyview,
709 WIN_CONSUME_EVENTS,
710 WIN_ASCII_EVENTS, WIN_META_EVENTS,
711 WIN_MOUSE_BUTTONS, WIN_UP_EVENTS,
712 LOC_DRAG,
713 SHIFT_LEFT, SHIFT_RIGHT, SHIFT_CTRL, SHIFT_META,
714 WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
715 0,
716 WIN_COLLAPSE_EXPOSURES, FALSE,
717 0);
718
719 default_cursor = xv_get(ttyview, WIN_CURSOR);
720 jove_cursor = xv_create(XV_NULL, CURSOR,
721 CURSOR_IMAGE, &cursor_pix,
722 CURSOR_XHOT, 8,
723 CURSOR_YHOT, 8,
724 0);
725 cut_cursor = xv_create(XV_NULL, CURSOR,
726 CURSOR_IMAGE, &cut_pix,
727 CURSOR_XHOT, 8,
728 CURSOR_YHOT, 8,
729 0);
730 copy_cursor = xv_create(XV_NULL, CURSOR,
731 CURSOR_IMAGE, &copy_pix,
732 CURSOR_XHOT, 8,
733 CURSOR_YHOT, 8,
734 0);
735 paste_cursor = xv_create(XV_NULL, CURSOR,
736 CURSOR_IMAGE, &paste_pix,
737 CURSOR_XHOT, 8,
738 CURSOR_YHOT, 8,
739 0);
740 set_cursor(jove_cursor);
741
742 /* Interpose my event function */
743 error_code =
744 (int) notify_interpose_event_func
745 (ttyview, input_event_filter_function, NOTIFY_SAFE) +
746 (int) notify_interpose_event_func
747 (ttysw, tty_event_filter_function, NOTIFY_SAFE);
748 if (error_code != 0) { /* Barf */
749 fprintf(stderr, "notify_interpose_event_func got %d.\n", error_code);
750 exit(1);
751 }
752 menu_init();
753
754 bind_function_keys((KeySym)XK_L1, 10, 192);
755 bind_function_keys((KeySym)XK_Help, 1, 202);
756 bind_function_keys((KeySym)XK_F1, 10, 224);
757 #ifdef SunXK_F36
758 bind_function_keys((KeySym)SunXK_F36, 2, 234); /* for Suns only */
759 #endif
760 bind_function_keys((KeySym)XK_R1, 15, 208);
761 /*
762 * But note that the keys R7-R15 are intercepted by XView which
763 * imposes its own bindings
764 */
765 bind_function_keys((KeySym)XK_Insert, 1, 247);
766 bind_function_keys((KeySym)XK_KP_0, 1, 247);
767 bind_function_keys((KeySym)XK_KP_Decimal, 1, 249);
768 bind_function_keys((KeySym)XK_KP_Enter, 1, 250);
769 bind_function_keys((KeySym)XK_KP_Add, 1, 253);
770 bind_function_keys((KeySym)XK_KP_Subtract, 1, 254);
771
772 window_fit(frame);
773 window_main_loop(frame);/* And away we go */
774 return 0; /* if this is ever reached */
775 }