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