Mercurial > hg > xemacs-beta
annotate src/gpmevent.c @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| 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 */ |