Mercurial > hg > xemacs-beta
annotate src/gpmevent.c @ 5518:3cc7470ea71c
gnuclient: if TMPDIR was set and connect failed, try again with /tmp
2011-06-03 Aidan Kehoe <kehoea@parhasard.net>
* gnuslib.c (connect_to_unix_server):
Retry with /tmp as a directory in which to search for Unix sockets
if an attempt to connect with some other directory failed (which
may be because gnuclient and gnuserv don't share an environment
value for TMPDIR, or because gnuserv was compiled with USE_TMPDIR
turned off).
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Fri, 03 Jun 2011 18:40:57 +0100 |
| parents | 2aa9cd456ae7 |
| children | 56144c8593a8 |
| rev | line source |
|---|---|
| 440 | 1 /* GPM (General purpose mouse) functions |
| 428 | 2 Copyright (C) 1997 William M. Perry <wmperry@gnu.org> |
| 3 Copyright (C) 1999 Free Software Foundation, Inc. | |
| 793 | 4 Copyright (C) 2002 Ben Wing. |
| 5 | |
| 6 This file is part of XEmacs. | |
| 7 | |
|
5405
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
8 XEmacs is free software: you can redistribute it and/or modify it |
| 793 | 9 under the terms of the GNU General Public License as published by the |
|
5405
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
10 Free Software Foundation, either version 3 of the License, or (at your |
|
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
11 option) any later version. |
|
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
12 |
| 793 | 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
|
5405
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
17 |
| 793 | 18 You should have received a copy of the GNU General Public License |
|
5405
2aa9cd456ae7
Move src/ to GPLv3.
Mike Sperber <sperber@deinprogramm.de>
parents:
4953
diff
changeset
|
19 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 20 |
| 21 /* Synched up with: Not in FSF. */ | |
| 22 | |
| 23 /* Authors: William Perry */ | |
| 24 | |
| 25 #include <config.h> | |
| 26 #include "lisp.h" | |
| 793 | 27 |
| 28 #include "commands.h" | |
| 29 #include "console-tty.h" | |
| 428 | 30 #include "console.h" |
| 31 #include "device.h" | |
| 32 #include "events.h" | |
| 793 | 33 #include "lstream.h" |
| 34 #include "process.h" | |
| 428 | 35 #include "sysdep.h" |
| 876 | 36 #include "frame.h" |
| 37 #include "device-impl.h" | |
| 38 #include "console-impl.h" | |
| 39 #include "console-tty-impl.h" | |
| 793 | 40 |
| 428 | 41 #include "sysproc.h" /* for MAXDESC */ |
| 42 | |
| 43 #ifdef HAVE_GPM | |
| 44 #include "gpmevent.h" | |
| 45 #include <gpm.h> | |
| 46 | |
| 47 #define KG_SHIFT 0 | |
| 48 #define KG_CTRL 2 | |
| 49 #define KG_ALT 3 | |
| 50 | |
| 51 extern int gpm_tried; | |
| 52 extern void *gpm_stack; | |
| 53 | |
| 54 static int (*orig_event_pending_p) (int); | |
| 440 | 55 static void (*orig_next_event_cb) (Lisp_Event *); |
| 428 | 56 |
| 57 static Lisp_Object gpm_event_queue; | |
| 58 static Lisp_Object gpm_event_queue_tail; | |
| 59 | |
| 793 | 60 struct __gpm_state |
| 61 { | |
| 62 int gpm_tried; | |
| 63 int gpm_flag; | |
| 64 void *gpm_stack; | |
| 428 | 65 }; |
| 66 | |
| 67 static struct __gpm_state gpm_state_information[MAXDESC]; | |
| 68 | |
| 69 static void | |
| 70 store_gpm_state (int fd) | |
| 71 { | |
| 793 | 72 gpm_state_information[fd].gpm_tried = gpm_tried; |
| 73 gpm_state_information[fd].gpm_flag = gpm_flag; | |
| 74 gpm_state_information[fd].gpm_stack = gpm_stack; | |
| 428 | 75 } |
| 76 | |
| 77 static void | |
| 78 restore_gpm_state (int fd) | |
| 79 { | |
| 793 | 80 gpm_tried = gpm_state_information[fd].gpm_tried; |
| 81 gpm_flag = gpm_state_information[fd].gpm_flag; | |
| 82 gpm_stack = gpm_state_information[fd].gpm_stack; | |
| 83 gpm_consolefd = gpm_fd = fd; | |
| 428 | 84 } |
| 85 | |
| 86 static void | |
| 87 clear_gpm_state (int fd) | |
| 88 { | |
| 793 | 89 if (fd >= 0) |
| 90 memset (&gpm_state_information[fd], '\0', sizeof (struct __gpm_state)); | |
| 91 gpm_tried = gpm_flag = 1; | |
| 92 gpm_fd = gpm_consolefd = -1; | |
| 93 gpm_stack = NULL; | |
| 428 | 94 } |
| 95 | |
| 96 static int | |
| 440 | 97 get_process_infd (Lisp_Process *p) |
| 428 | 98 { |
| 853 | 99 Lisp_Object instr, outstr, errstr; |
| 100 get_process_streams (p, &instr, &outstr, &errstr); | |
| 428 | 101 assert (!NILP (instr)); |
| 102 return filedesc_stream_fd (XLSTREAM (instr)); | |
| 103 } | |
| 104 | |
| 105 DEFUN ("receive-gpm-event", Freceive_gpm_event, 0, 2, 0, /* | |
| 106 Run GPM_GetEvent(). | |
| 107 This function is the process handler for the GPM connection. | |
| 108 */ | |
| 2286 | 109 (process, UNUSED (string))) |
| 428 | 110 { |
| 793 | 111 Gpm_Event ev; |
| 112 int modifiers = 0; | |
| 113 int button = 1; | |
| 114 Lisp_Object fake_event = Qnil; | |
| 115 Lisp_Event *event = NULL; | |
| 116 struct gcpro gcpro1; | |
| 117 static int num_events; | |
| 428 | 118 |
| 793 | 119 CHECK_PROCESS (process); |
| 428 | 120 |
| 793 | 121 restore_gpm_state (get_process_infd (XPROCESS (process))); |
| 428 | 122 |
| 793 | 123 if (!Gpm_GetEvent (&ev)) |
| 124 { | |
| 125 warn_when_safe (Qnil, Qerror, | |
| 126 "Gpm_GetEvent failed - %d", gpm_fd); | |
| 127 return (Qzero); | |
| 128 } | |
| 428 | 129 |
| 793 | 130 GCPRO1 (fake_event); |
| 428 | 131 |
| 793 | 132 num_events++; |
| 133 | |
| 134 fake_event = Fmake_event (Qnil, Qnil); | |
| 135 event = XEVENT (fake_event); | |
| 428 | 136 |
| 793 | 137 event->timestamp = 0; |
| 138 event->channel = Fselected_frame (Qnil); /* CONSOLE_SELECTED_FRAME (con); */ | |
| 428 | 139 |
| 793 | 140 /* Whow, wouldn't named defines be NICE!?!?! */ |
| 141 modifiers = 0; | |
| 428 | 142 |
| 793 | 143 if (ev.modifiers & 1) modifiers |= XEMACS_MOD_SHIFT; |
| 144 if (ev.modifiers & 2) modifiers |= XEMACS_MOD_META; | |
| 145 if (ev.modifiers & 4) modifiers |= XEMACS_MOD_CONTROL; | |
| 146 if (ev.modifiers & 8) modifiers |= XEMACS_MOD_META; | |
| 147 | |
| 148 if (ev.buttons & GPM_B_LEFT) | |
| 149 button = 1; | |
| 150 else if (ev.buttons & GPM_B_MIDDLE) | |
| 151 button = 2; | |
| 152 else if (ev.buttons & GPM_B_RIGHT) | |
| 153 button = 3; | |
| 428 | 154 |
| 793 | 155 switch (GPM_BARE_EVENTS (ev.type)) |
| 156 { | |
| 157 case GPM_DOWN: | |
| 158 case GPM_UP: | |
| 934 | 159 SET_EVENT_TYPE (event, |
| 160 (ev.type & GPM_DOWN) ? button_press_event : button_release_event); | |
| 1204 | 161 SET_EVENT_BUTTON_X (event, ev.x); |
| 162 SET_EVENT_BUTTON_Y (event, ev.y); | |
| 163 SET_EVENT_BUTTON_BUTTON (event, button); | |
| 164 SET_EVENT_BUTTON_MODIFIERS (event, modifiers); | |
| 793 | 165 break; |
| 166 case GPM_MOVE: | |
| 167 case GPM_DRAG: | |
| 934 | 168 SET_EVENT_TYPE (event, pointer_motion_event); |
| 1204 | 169 SET_EVENT_MOTION_X (event, ev.x); |
| 170 SET_EVENT_MOTION_Y (event, ev.y); | |
| 171 SET_EVENT_MOTION_MODIFIERS (event, modifiers); | |
| 793 | 172 default: |
| 173 /* This will never happen */ | |
| 174 break; | |
| 175 } | |
| 428 | 176 |
| 793 | 177 /* Handle the event */ |
| 178 enqueue_event (fake_event, &gpm_event_queue, &gpm_event_queue_tail); | |
| 428 | 179 |
| 793 | 180 UNGCPRO; |
| 428 | 181 |
| 793 | 182 return (Qzero); |
| 428 | 183 } |
| 184 | |
| 185 static void turn_off_gpm (char *process_name) | |
| 186 { | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
187 Lisp_Object process = Fget_process (build_cistring (process_name)); |
| 793 | 188 int fd = -1; |
| 428 | 189 |
| 793 | 190 if (NILP (process)) |
| 191 /* Something happened to our GPM process - fail silently */ | |
| 192 return; | |
| 428 | 193 |
| 793 | 194 fd = get_process_infd (XPROCESS (process)); |
| 428 | 195 |
| 793 | 196 restore_gpm_state (fd); |
| 428 | 197 |
| 793 | 198 Gpm_Close(); |
| 428 | 199 |
| 793 | 200 clear_gpm_state (fd); |
| 428 | 201 |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
202 Fdelete_process (build_cistring (process_name)); |
| 428 | 203 } |
| 204 | |
| 205 #ifdef TIOCLINUX | |
| 206 static Lisp_Object | |
| 2286 | 207 tty_get_foreign_selection (Lisp_Object UNUSED (selection_symbol), |
| 208 Lisp_Object UNUSED (target_type)) | |
| 428 | 209 { |
| 793 | 210 /* This function can GC */ |
| 211 struct device *d = decode_device (Qnil); | |
| 212 int fd = DEVICE_INFD (d); | |
| 213 char c = 3; | |
| 214 Lisp_Object output_stream = Qnil; | |
| 215 Lisp_Object terminal_stream = Qnil; | |
| 216 Lisp_Object output_string = Qnil; | |
| 217 struct gcpro gcpro1,gcpro2,gcpro3; | |
| 218 | |
| 219 GCPRO3(output_stream,terminal_stream,output_string); | |
| 428 | 220 |
| 793 | 221 /* The ioctl() to paste actually puts things in the input queue of |
| 222 ** the virtual console, so we need to trap that data, since we are | |
| 223 ** supposed to return the actual string selection from this | |
| 224 ** function. | |
| 225 */ | |
| 428 | 226 |
| 793 | 227 /* I really hate doing this, but it doesn't seem to cause any |
| 228 ** problems, and it makes the Lstream_read stuff further down | |
| 229 ** error out correctly instead of trying to indefinitely read from | |
| 230 ** the console. | |
| 231 ** | |
| 232 ** There is no set_descriptor_blocking() function call, but in my | |
| 233 ** testing under linux, it has not proved fatal to leave the | |
| 234 ** descriptor in non-blocking mode. | |
| 235 ** | |
| 236 ** William Perry Nov 5, 1999 | |
| 237 */ | |
| 238 set_descriptor_non_blocking (fd); | |
| 428 | 239 |
| 793 | 240 /* We need two streams, one for reading from the selected device, |
| 241 ** and one to write the data into. There is no writable version | |
| 242 ** of the lisp-string lstream, so we make do with a resizing | |
| 243 ** buffer stream, and make a string out of it after we are | |
| 244 ** done. | |
| 245 */ | |
| 246 output_stream = make_resizing_buffer_output_stream (); | |
| 247 terminal_stream = make_filedesc_input_stream (fd, 0, -1, LSTR_BLOCKED_OK); | |
| 248 output_string = Qnil; | |
| 249 | |
| 250 /* #### We should arguably use a specbind() and an unwind routine here, | |
| 251 ** #### but I don't care that much right now. | |
| 252 */ | |
| 253 if (NILP (output_stream) || NILP (terminal_stream)) | |
| 254 /* Should we signal an error here? */ | |
| 255 goto out; | |
| 428 | 256 |
| 793 | 257 if (ioctl (fd, TIOCLINUX, &c) < 0) |
| 258 { | |
| 259 /* Could not get the selection - eek */ | |
| 260 UNGCPRO; | |
| 261 return (Qnil); | |
| 262 } | |
| 428 | 263 |
| 793 | 264 while (1) |
| 265 { | |
| 867 | 266 Ibyte tempbuf[1024]; /* some random amount */ |
| 793 | 267 Bytecount i; |
| 268 Bytecount size_in_bytes = | |
| 269 Lstream_read (XLSTREAM (terminal_stream), | |
| 270 tempbuf, sizeof (tempbuf)); | |
| 271 | |
| 272 if (size_in_bytes <= 0) | |
| 273 /* end of the stream */ | |
| 274 break; | |
| 275 | |
| 276 /* convert CR->LF */ | |
| 277 for (i = 0; i < size_in_bytes; i++) | |
| 428 | 278 { |
| 793 | 279 if (tempbuf[i] == '\r') |
| 280 tempbuf[i] = '\n'; | |
| 428 | 281 } |
| 282 | |
| 793 | 283 Lstream_write (XLSTREAM (output_stream), tempbuf, size_in_bytes); |
| 284 } | |
| 428 | 285 |
| 793 | 286 Lstream_flush (XLSTREAM (output_stream)); |
| 428 | 287 |
| 793 | 288 output_string = |
| 289 make_string (resizing_buffer_stream_ptr (XLSTREAM (output_stream)), | |
| 290 Lstream_byte_count (XLSTREAM (output_stream))); | |
| 428 | 291 |
| 793 | 292 Lstream_delete (XLSTREAM (output_stream)); |
| 293 Lstream_delete (XLSTREAM (terminal_stream)); | |
| 428 | 294 |
| 295 out: | |
| 793 | 296 UNGCPRO; |
| 297 return (output_string); | |
| 428 | 298 } |
| 299 | |
| 300 static Lisp_Object | |
| 2286 | 301 tty_selection_exists_p (Lisp_Object UNUSED (selection), |
| 302 Lisp_Object UNUSED (selection_type)) | |
| 428 | 303 { |
| 793 | 304 return (Qt); |
| 428 | 305 } |
| 306 #endif /* TIOCLINUX */ | |
| 307 | |
| 308 #if 0 | |
| 309 static Lisp_Object | |
| 442 | 310 tty_own_selection (Lisp_Object selection_name, Lisp_Object selection_value, |
| 311 Lisp_Object how_to_add, Lisp_Object selection_type) | |
| 428 | 312 { |
| 793 | 313 /* There is no way to do this cleanly - the GPM selection |
| 314 ** 'protocol' (actually the TIOCLINUX ioctl) requires a start and | |
| 315 ** end position on the _screen_, not a string to stick in there. | |
| 316 ** Lame. | |
| 317 ** | |
| 318 ** William Perry Nov 4, 1999 | |
| 319 */ | |
| 428 | 320 } |
| 321 #endif | |
| 322 | |
| 323 /* This function appears to work once in a blue moon. I'm not sure | |
| 793 | 324 ** exactly why either. *sigh* |
| 325 ** | |
| 326 ** William Perry Nov 4, 1999 | |
| 327 ** | |
| 328 ** Apparently, this is the way (mouse-position) is supposed to work, | |
| 329 ** and I was just expecting something else. (mouse-pixel-position) | |
| 330 ** works just fine. | |
| 331 ** | |
| 332 ** William Perry Nov 7, 1999 | |
| 333 */ | |
| 428 | 334 static int |
| 335 tty_get_mouse_position (struct device *d, Lisp_Object *frame, int *x, int *y) | |
| 336 { | |
| 793 | 337 Gpm_Event ev; |
| 338 int num_buttons; | |
| 428 | 339 |
| 793 | 340 memset(&ev,'\0',sizeof(ev)); |
| 428 | 341 |
| 793 | 342 num_buttons = Gpm_GetSnapshot(&ev); |
| 428 | 343 |
| 793 | 344 if (!num_buttons) |
| 345 /* This means there are events pending... */ | |
| 428 | 346 |
| 793 | 347 /* #### In theory, we should drain the events pending, stick |
| 348 ** #### them in the queue, and return the mouse position | |
| 349 ** #### anyway. | |
| 350 */ | |
| 351 return (-1); | |
| 352 *x = ev.x; | |
| 353 *y = ev.y; | |
| 354 *frame = DEVICE_SELECTED_FRAME (d); | |
| 355 return (1); | |
| 428 | 356 } |
| 357 | |
| 358 static void | |
| 2286 | 359 tty_set_mouse_position (struct window *UNUSED (w), int UNUSED (x), |
| 360 int UNUSED (y)) | |
| 428 | 361 { |
| 793 | 362 /* |
| 363 #### I couldn't find any GPM functions that set the mouse position. | |
| 364 #### Mr. Perry had left this function empty; that must be why. | |
| 365 #### karlheg | |
| 366 */ | |
| 428 | 367 } |
| 368 | |
| 369 static int gpm_event_pending_p (int user_p) | |
| 370 { | |
| 793 | 371 Lisp_Object event; |
| 428 | 372 |
| 793 | 373 EVENT_CHAIN_LOOP (event, gpm_event_queue) |
| 374 { | |
| 375 if (!user_p || command_event_p (event)) | |
| 376 return (1); | |
| 377 } | |
| 378 return (orig_event_pending_p (user_p)); | |
| 428 | 379 } |
| 380 | |
| 440 | 381 static void gpm_next_event_cb (Lisp_Event *event) |
| 428 | 382 { |
| 793 | 383 /* #### It would be nice to preserve some sort of ordering of the |
| 384 ** #### different types of events, but that would be quite a bit | |
| 385 ** #### of work, and would more than likely break the abstraction | |
| 386 ** #### between the other event loops and this one. | |
| 387 */ | |
| 440 | 388 |
| 793 | 389 if (!NILP (gpm_event_queue)) |
| 390 { | |
| 391 Lisp_Object queued_event = | |
| 392 dequeue_event (&gpm_event_queue, &gpm_event_queue_tail); | |
| 393 *event = *(XEVENT (queued_event)); | |
| 394 | |
| 395 if (event->event_type == pointer_motion_event) | |
| 428 | 396 { |
| 793 | 397 struct device *d = decode_device (event->channel); |
| 398 int fd = DEVICE_INFD (d); | |
| 428 | 399 |
| 793 | 400 /* Ok, now this is just freaky. Bear with me though. |
| 401 ** | |
| 402 ** If you run gnuclient and attach to a XEmacs running in | |
| 403 ** X or on another TTY, the mouse cursor does not get | |
| 404 ** drawn correctly. This is because the ioctl() fails | |
| 405 ** with EPERM because the TTY specified is not our | |
| 406 ** controlling terminal. If you are the superuser, it | |
| 407 ** will work just spiffy. The appropriate source file (at | |
| 408 ** least in linux 2.2.x) is | |
| 409 ** .../linux/drivers/char/console.c in the function | |
| 410 ** tioclinux(). The following bit of code is brutal to | |
| 411 ** us: | |
| 412 ** | |
| 413 ** if (current->tty != tty && !suser()) | |
| 414 ** return -EPERM; | |
| 415 ** | |
| 416 ** I even tried setting us as a process leader, removing | |
| 417 ** our controlling terminal, and then using the TIOCSCTTY | |
| 418 ** to set up a new controlling terminal, all with no luck. | |
| 419 ** | |
| 420 ** What is even weirder is if you run XEmacs in a VC, and | |
| 421 ** attach to it from another VC with gnuclient, go back to | |
| 422 ** the original VC and hit a key, the mouse pointer | |
| 423 ** displays (in BOTH VCs), until you hit a key in the | |
| 424 ** second VC, after which it does not display in EITHER | |
| 425 ** VC. Bizarre, no? | |
| 426 ** | |
| 427 ** All I can say is thank god Linux comes with source code | |
| 428 ** or I would have been completely confused. Well, ok, | |
| 429 ** I'm still completely confused. I don't see why they | |
| 430 ** don't just check the permissions on the device | |
| 431 ** (actually, if you have enough access to it to get the | |
| 432 ** console's file descriptor, you should be able to do | |
| 433 ** with it as you wish, but maybe that is just me). | |
| 434 ** | |
| 435 ** William M. Perry - Nov 9, 1999 | |
| 436 */ | |
| 428 | 437 |
| 1204 | 438 Gpm_DrawPointer (EVENT_MOTION_X (event),EVENT_MOTION_Y (event), fd); |
| 428 | 439 } |
| 440 | |
| 793 | 441 return; |
| 442 } | |
| 443 | |
| 444 orig_next_event_cb (event); | |
| 428 | 445 } |
| 446 | |
| 447 static void hook_event_callbacks_once (void) | |
| 448 { | |
| 793 | 449 static int hooker; |
| 428 | 450 |
| 793 | 451 if (!hooker) |
| 452 { | |
| 453 orig_event_pending_p = event_stream->event_pending_p; | |
| 454 orig_next_event_cb = event_stream->next_event_cb; | |
| 455 event_stream->event_pending_p = gpm_event_pending_p; | |
| 456 event_stream->next_event_cb = gpm_next_event_cb; | |
| 457 hooker = 1; | |
| 458 } | |
| 428 | 459 } |
| 460 | |
| 461 static void hook_console_methods_once (void) | |
| 462 { | |
| 793 | 463 static int hooker; |
| 428 | 464 |
| 793 | 465 if (!hooker) |
| 466 { | |
| 467 /* Install the mouse position methods for the TTY console type */ | |
| 468 CONSOLE_HAS_METHOD (tty, get_mouse_position); | |
| 469 CONSOLE_HAS_METHOD (tty, set_mouse_position); | |
| 470 CONSOLE_HAS_METHOD (tty, get_foreign_selection); | |
| 471 CONSOLE_HAS_METHOD (tty, selection_exists_p); | |
| 428 | 472 #if 0 |
| 793 | 473 CONSOLE_HAS_METHOD (tty, own_selection); |
| 428 | 474 #endif |
| 793 | 475 } |
| 428 | 476 } |
| 477 | |
| 478 DEFUN ("gpm-enabled-p", Fgpm_enabled_p, 0, 1, 0, /* | |
| 479 Return non-nil if GPM mouse support is currently enabled on DEVICE. | |
| 480 */ | |
| 793 | 481 (device)) |
| 428 | 482 { |
| 793 | 483 char *console_name = ttyname (DEVICE_INFD (decode_device (device))); |
| 484 char process_name[1024]; | |
| 485 Lisp_Object proc; | |
| 428 | 486 |
| 793 | 487 if (!console_name) |
| 488 return (Qnil); | |
| 428 | 489 |
| 793 | 490 memset (process_name, '\0', sizeof(process_name)); |
| 491 snprintf (process_name, sizeof(process_name) - 1, "gpm for %s", | |
| 492 console_name); | |
| 428 | 493 |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
494 proc = Fget_process (build_cistring (process_name)); |
| 428 | 495 |
| 793 | 496 if (NILP (proc)) |
| 497 return (Qnil); | |
| 428 | 498 |
| 793 | 499 if (1) /* (PROCESS_LIVE_P (proc)) */ |
| 500 return (Qt); | |
| 501 return (Qnil); | |
| 428 | 502 } |
| 503 | |
| 504 DEFUN ("gpm-enable", Fgpm_enable, 0, 2, 0, /* | |
| 505 Toggle accepting of GPM mouse events. | |
| 506 */ | |
| 793 | 507 (device, arg)) |
| 428 | 508 { |
| 793 | 509 Gpm_Connect conn; |
| 510 int rval; | |
| 511 Lisp_Object gpm_process; | |
| 512 Lisp_Object gpm_filter; | |
| 513 struct device *d = decode_device (device); | |
| 514 int fd = DEVICE_INFD (d); | |
| 515 char *console_name = ttyname (fd); | |
| 516 char process_name[1024]; | |
| 428 | 517 |
| 793 | 518 hook_event_callbacks_once (); |
| 519 hook_console_methods_once (); | |
| 520 | |
| 521 if (noninteractive) | |
| 522 invalid_operation ("Can't connect to GPM in batch mode", Qunbound); | |
| 428 | 523 |
| 793 | 524 if (!console_name) |
| 525 /* Something seriously wrong here... */ | |
| 526 return (Qnil); | |
| 527 | |
| 528 memset (process_name, '\0', sizeof(process_name)); | |
| 529 snprintf (process_name, sizeof(process_name) - 1, "gpm for %s", | |
| 530 console_name); | |
| 428 | 531 |
| 793 | 532 if (NILP (arg)) |
| 533 { | |
| 534 turn_off_gpm (process_name); | |
| 535 return (Qnil); | |
| 536 } | |
| 428 | 537 |
| 793 | 538 /* DANGER DANGER. |
| 539 ** Though shalt not call (gpm-enable t) after we have already | |
| 540 ** started, or stuff blows up. | |
| 541 */ | |
| 542 if (!NILP (Fgpm_enabled_p (device))) | |
| 543 invalid_operation ("GPM already enabled for this console", Qunbound); | |
| 428 | 544 |
| 793 | 545 conn.eventMask = GPM_DOWN|GPM_UP|GPM_MOVE|GPM_DRAG; |
| 546 conn.defaultMask = GPM_MOVE; | |
| 547 conn.minMod = 0; | |
| 548 conn.maxMod = ((1 << KG_SHIFT) | (1 << KG_ALT) | (1 << KG_CTRL)); | |
| 428 | 549 |
| 793 | 550 /* Reset some silly static variables so that multiple Gpm_Open() |
| 551 ** calls have even a slight chance of working | |
| 552 */ | |
| 553 gpm_tried = 0; | |
| 554 gpm_flag = 0; | |
| 555 gpm_stack = NULL; | |
| 428 | 556 |
| 793 | 557 /* Make sure Gpm_Open() does ioctl() on the correct |
| 558 ** descriptor, or it can get the wrong terminal sizes, etc. | |
| 559 */ | |
| 560 gpm_consolefd = fd; | |
| 440 | 561 |
| 793 | 562 /* We have to pass the virtual console manually, otherwise if you |
| 3025 | 563 ** use `gnuclient -nw' to connect to an XEmacs that is running in |
| 793 | 564 ** X, Gpm_Open() tries to use ttyname(0 | 1 | 2) to find out which |
| 565 ** console you are using, which is of course not correct for the | |
| 566 ** new tty device. | |
| 567 */ | |
| 568 if (strncmp (console_name, "/dev/tty", 8) || !isdigit (console_name[8])) | |
| 569 /* Urk, something really wrong */ | |
| 570 return (Qnil); | |
| 428 | 571 |
| 793 | 572 rval = Gpm_Open (&conn, atoi (console_name + 8)); |
| 428 | 573 |
| 793 | 574 switch (rval) |
| 575 { | |
| 576 case -1: /* General failure */ | |
| 577 break; | |
| 578 case -2: /* We are running under an XTerm */ | |
| 579 Gpm_Close(); | |
| 580 break; | |
| 581 default: | |
| 582 /* Is this really necessary? */ | |
| 583 set_descriptor_non_blocking (gpm_fd); | |
| 584 store_gpm_state (gpm_fd); | |
| 585 gpm_process = | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
586 connect_to_file_descriptor (build_cistring (process_name), Qnil, |
| 793 | 587 make_int (gpm_fd), |
| 588 make_int (gpm_fd)); | |
| 428 | 589 |
| 793 | 590 if (!NILP (gpm_process)) |
| 591 { | |
| 592 rval = 0; | |
| 593 Fprocess_kill_without_query (gpm_process, Qnil); | |
| 2834 | 594 gpm_filter = GET_DEFUN_LISP_OBJECT (Freceive_gpm_event); |
| 853 | 595 set_process_filter (gpm_process, gpm_filter, 1, 0); |
| 428 | 596 |
| 793 | 597 /* Keep track of the device for later */ |
| 598 /* Fput (gpm_process, intern ("gpm-device"), device); */ | |
| 428 | 599 } |
| 793 | 600 else |
| 601 { | |
| 602 Gpm_Close (); | |
| 603 rval = -1; | |
| 604 } | |
| 605 } | |
| 428 | 606 |
| 793 | 607 return (rval ? Qnil : Qt); |
| 428 | 608 } |
| 609 | |
| 610 void vars_of_gpmevent (void) | |
| 611 { | |
| 793 | 612 gpm_event_queue = Qnil; |
| 613 gpm_event_queue_tail = Qnil; | |
| 614 staticpro (&gpm_event_queue); | |
| 615 staticpro (&gpm_event_queue_tail); | |
| 1204 | 616 dump_add_root_lisp_object (&gpm_event_queue); |
| 617 dump_add_root_lisp_object (&gpm_event_queue_tail); | |
| 428 | 618 } |
| 619 | |
| 620 void syms_of_gpmevent (void) | |
| 621 { | |
| 793 | 622 DEFSUBR (Freceive_gpm_event); |
| 623 DEFSUBR (Fgpm_enable); | |
| 624 DEFSUBR (Fgpm_enabled_p); | |
| 428 | 625 } |
| 626 | |
| 627 #endif /* HAVE_GPM */ |