Mercurial > hg > xemacs-beta
annotate src/event-Xt.c @ 4976:16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-04 Ben Wing <ben@xemacs.org>
* alloc.c (release_breathing_space):
* alloc.c (resize_string):
* alloc.c (sweep_lcrecords_1):
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1):
* alloc.c (ADDITIONAL_FREE_compiled_function):
* alloc.c (compact_string_chars):
* alloc.c (ADDITIONAL_FREE_string):
* alloc.c (sweep_strings):
* alloca.c (xemacs_c_alloca):
* alsaplay.c (alsa_play_sound_file):
* buffer.c (init_initial_directory):
* buffer.h:
* buffer.h (BUFFER_FREE):
* console-stream.c (stream_delete_console):
* console-tty.c (free_tty_console_struct):
* data.c (Fnumber_to_string):
* device-gtk.c (gtk_init_device):
* device-gtk.c (free_gtk_device_struct):
* device-gtk.c (gtk_delete_device):
* device-msw.c (mswindows_delete_device):
* device-msw.c (msprinter_delete_device):
* device-tty.c (free_tty_device_struct):
* device-tty.c (tty_delete_device):
* device-x.c (x_init_device):
* device-x.c (free_x_device_struct):
* device-x.c (x_delete_device):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* dired-msw.c (Fmswindows_insert_directory):
* dired.c (free_user_cache):
* dired.c (user_name_completion_unwind):
* doc.c (unparesseuxify_doc_string):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (emacs_doprnt_1):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_free):
* dumper.c (pdump_file_unmap):
* dynarr.c:
* dynarr.c (Dynarr_free):
* editfns.c (uncache_home_directory):
* editfns.c (Fset_time_zone_rule):
* elhash.c:
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (maphash_unwind):
* emacs.c (make_arg_list_1):
* emacs.c (free_argc_argv):
* emacs.c (sort_args):
* emacs.c (Frunning_temacs_p):
* emodules.c (attempt_module_delete):
* eval.c (free_pointer):
* event-Xt.c (unselect_filedesc):
* event-Xt.c (emacs_Xt_select_process):
* event-gtk.c (unselect_filedesc):
* event-gtk.c (dragndrop_data_received):
* event-msw.c (winsock_closer):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-stream.c (finalize_command_builder):
* event-stream.c (free_command_builder):
* extents.c (free_gap_array):
* extents.c (free_extent_list):
* extents.c (free_soe):
* extents.c (extent_fragment_delete):
* extents.c (extent_priority_sort_function):
* file-coding.c (make_coding_system_1):
* file-coding.c (coding_finalizer):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (chain_finalize_coding_stream_1):
* file-coding.c (chain_finalize):
* file-coding.c (free_detection_state):
* file-coding.c (coding_category_symbol_to_id):
* fileio.c:
* fileio.c (Ffile_name_directory):
* fileio.c (if):
* fileio.c (Ffile_symlink_p):
* filelock.c (FREE_LOCK_INFO):
* filelock.c (current_lock_owner):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* frame-gtk.c (gtk_delete_frame):
* frame-msw.c (mswindows_delete_frame):
* frame-msw.c (msprinter_delete_frame):
* frame-x.c (x_cde_destroy_callback):
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_delete_frame):
* frame.c (update_frame_title):
* frame.c (Fset_frame_pointer):
* gc.c (register_for_finalization):
* gccache-gtk.c (free_gc_cache):
* gccache-gtk.c (gc_cache_lookup):
* gccache-x.c (free_gc_cache):
* gccache-x.c (gc_cache_lookup):
* glyphs-eimage.c:
* glyphs-eimage.c (jpeg_instantiate_unwind):
* glyphs-eimage.c (gif_instantiate_unwind):
* glyphs-eimage.c (png_instantiate_unwind):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate_unwind):
* glyphs-gtk.c (convert_EImage_to_GDKImage):
* glyphs-gtk.c (gtk_finalize_image_instance):
* glyphs-gtk.c (gtk_init_image_instance_from_eimage):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-msw.c (convert_EImage_to_DIBitmap):
* glyphs-msw.c (mswindows_init_image_instance_from_eimage):
* glyphs-msw.c (mswindows_initialize_image_instance_mask):
* glyphs-msw.c (xpm_to_eimage):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (xbm_create_bitmap_from_data):
* glyphs-msw.c (mswindows_finalize_image_instance):
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs-x.c (x_finalize_image_instance):
* glyphs-x.c (x_init_image_instance_from_eimage):
* glyphs-x.c (x_xpm_instantiate):
* gui-x.c (free_popup_widget_value_tree):
* hash.c (free_hash_table):
* hash.c (grow_hash_table):
* hash.c (pregrow_hash_table_if_necessary):
* imgproc.c (build_EImage_quantable):
* insdel.c (uninit_buffer_text):
* intl-win32.c (convert_multibyte_to_internal_malloc):
* intl.c:
* intl.c (Fset_current_locale):
* keymap.c:
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* lisp.h:
* lisp.h (xfree):
* lstream.c (Lstream_close):
* lstream.c (resizing_buffer_closer):
* mule-coding.c:
* mule-coding.c (iso2022_finalize_detection_state):
* nt.c:
* nt.c (mswindows_get_long_filename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_opendir):
* nt.c (mswindows_closedir):
* nt.c (mswindows_readdir):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (Fmswindows_long_file_name):
* ntplay.c (nt_play_sound_file):
* ntplay.c (play_sound_data_1):
* number-gmp.c (gmp_free):
* number-gmp.c (init_number_gmp):
* number-mp.c (bignum_to_string):
* number-mp.c (BIGNUM_TO_TYPE):
* number.c (bignum_print):
* number.c (bignum_convfree):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-gtk.c (gtk_finalize_color_instance):
* objects-gtk.c (gtk_finalize_font_instance):
* objects-msw.c (mswindows_finalize_color_instance):
* objects-msw.c (mswindows_finalize_font_instance):
* objects-tty.c (tty_finalize_color_instance):
* objects-tty.c (tty_finalize_font_instance):
* objects-tty.c (tty_font_list):
* objects-x.c (x_finalize_color_instance):
* objects-x.c (x_finalize_font_instance):
* process.c:
* process.c (finalize_process):
* realpath.c:
* redisplay.c (add_propagation_runes):
* regex.c:
* regex.c (xfree):
* regex.c (REGEX_FREE_STACK):
* regex.c (FREE_STACK_RETURN):
* regex.c (regex_compile):
* regex.c (regexec):
* regex.c (regfree):
* scrollbar-gtk.c (gtk_free_scrollbar_instance):
* scrollbar-gtk.c (gtk_release_scrollbar_instance):
* scrollbar-msw.c (mswindows_free_scrollbar_instance):
* scrollbar-msw.c (unshow_that_mofo):
* scrollbar-x.c (x_free_scrollbar_instance):
* scrollbar-x.c (x_release_scrollbar_instance):
* select-gtk.c (emacs_gtk_selection_handle):
* select-msw.c (mswindows_own_selection):
* select-x.c:
* select-x.c (x_handle_selection_request):
* select-x.c (unexpect_property_change):
* select-x.c (x_handle_property_notify):
* select-x.c (receive_incremental_selection):
* select-x.c (x_get_window_property_as_lisp_data):
* select-x.c (Fx_get_cutbuffer_internal):
* specifier.c (finalize_specifier):
* syntax.c (uninit_buffer_syntax_cache):
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_lstat):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_ctime):
* sysdep.c (closedir):
* sysdep.c (DIRSIZ):
* termcap.c (tgetent):
* termcap.c (tprint):
* tests.c (Ftest_data_format_conversion):
* text.c (new_dfc_convert_copy_data):
* text.h (eifree):
* text.h (eito_alloca):
* text.h (eito_external):
* toolbar-msw.c (mswindows_output_toolbar):
* ui-gtk.c (CONVERT_RETVAL):
* ui-gtk.c (__allocate_object_storage):
* unicode.c (free_from_unicode_table):
* unicode.c (free_to_unicode_table):
* unicode.c (free_charset_unicode_tables):
* win32.c (mswindows_read_link_1):
Rename: xfree(VAL, TYPE)->xfree(VAL)
Command used:
gr 'xfree *\((.*),.*\);' 'xfree (\1);' *.[ch]
Followed by grepping for 'xfree.*,' and fixing anything left.
Rationale: Having to specify the TYPE argument is annoying and
error-prone. It was originally put in to work around warnings
due to strict aliasing but years and years ago I rewrote it
in a way that doesn't use the TYPE argument at all and no one
has complained since then. (And anyway, XEmacs is far from
ever being in compliance with strict aliasing and would require
far-reaching changes to get that way.)
author | Ben Wing <ben@xemacs.org> |
---|---|
date | Thu, 04 Feb 2010 07:28:14 -0600 |
parents | 304aebb79cd3 |
children | a7a237f818d9 |
rev | line source |
---|---|
428 | 1 /* The event_stream interface for X11 with Xt, and/or tty frames. |
2 Copyright (C) 1991-5, 1997 Free Software Foundation, Inc. | |
3 Copyright (C) 1995 Sun Microsystems, Inc. | |
1268 | 4 Copyright (C) 1996, 2001, 2002, 2003 Ben Wing. |
428 | 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. */ | |
22 | |
23 /* Synched up with: Not in FSF. */ | |
24 | |
25 #include <config.h> | |
26 #include "lisp.h" | |
27 | |
28 #include "blocktype.h" | |
771 | 29 #include "charset.h" |
428 | 30 #include "console.h" |
872 | 31 #include "device-impl.h" |
800 | 32 #include "elhash.h" |
428 | 33 #include "events.h" |
800 | 34 #include "file-coding.h" |
872 | 35 #include "frame-impl.h" |
800 | 36 #include "glyphs.h" |
37 #include "lstream.h" | |
428 | 38 #include "process.h" |
39 #include "redisplay.h" | |
800 | 40 #include "window.h" |
41 | |
42 #include "console-tty.h" | |
43 | |
872 | 44 #include "console-x-impl.h" |
800 | 45 #include "objects-x.h" |
46 #include "../lwlib/lwlib.h" | |
47 #include "EmacsFrame.h" | |
48 | |
49 #include "sysproc.h" /* for MAXDESC */ | |
428 | 50 #include "systime.h" |
51 | |
52 #include "xintrinsicp.h" /* CoreP.h needs this */ | |
53 #include <X11/CoreP.h> /* Numerous places access the fields of | |
54 a core widget directly. We could | |
55 use XtGetValues(), but ... */ | |
56 #include <X11/ShellP.h> | |
57 | |
800 | 58 #if defined (HAVE_XIM) && defined (XIM_MOTIF) |
1315 | 59 #include "xmotif.h" |
428 | 60 #endif |
61 | |
62 #ifdef HAVE_DRAGNDROP | |
63 #include "dragdrop.h" | |
64 #endif | |
65 | |
1292 | 66 #ifdef WIN32_ANY |
67 extern int mswindows_is_blocking; | |
68 #endif | |
69 | |
2828 | 70 /* For Russian C-x processing. */ |
3171 | 71 Lisp_Object Vx_us_keymap_description; |
72 Fixnum Vx_us_keymap_first_keycode; | |
2699 | 73 |
1094 | 74 /* used in glyphs-x.c */ |
75 void enqueue_focus_event (Widget wants_it, Lisp_Object frame, int in_p); | |
428 | 76 static void handle_focus_event_1 (struct frame *f, int in_p); |
863 | 77 static void handle_focus_event_2 (Window w, struct frame *f, int in_p); |
428 | 78 |
79 static struct event_stream *Xt_event_stream; | |
80 | |
81 /* With the new event model, all events go through XtDispatchEvent() | |
82 and are picked up by an event handler that is added to each frame | |
83 widget. (This is how it's supposed to be.) In the old method, | |
84 Emacs sucks out events directly from XtNextEvent() and only | |
85 dispatches the events that it doesn't need to deal with. This | |
86 old way has lots of corresponding junk that is no longer | |
87 necessary: lwlib extensions, synthetic XAnyEvents, unnecessary | |
88 magic events, etc. */ | |
89 | |
90 /* The one and only one application context that Emacs uses. */ | |
91 XtAppContext Xt_app_con; | |
92 | |
93 /* Do we accept events sent by other clients? */ | |
94 int x_allow_sendevents; | |
95 | |
96 #ifdef DEBUG_XEMACS | |
458 | 97 Fixnum debug_x_events; |
428 | 98 #endif |
99 | |
100 static int process_events_occurred; | |
101 static int tty_events_occurred; | |
450 | 102 static Widget widget_with_focus; |
428 | 103 |
104 /* Mask of bits indicating the descriptors that we wait for input on */ | |
1268 | 105 extern SELECT_TYPE input_wait_mask, non_fake_input_wait_mask; |
106 extern SELECT_TYPE process_only_mask, tty_only_mask; | |
428 | 107 |
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
108 /* #### This should be String, but G++ 4.3 doesn't apply the const |
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
109 specifier the same way for String (typedef'd to char*) and char*. */ |
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
110 static const char * x_fallback_resources[] = |
428 | 111 { |
112 /* This file is automatically generated from the app-defaults file | |
113 in ../etc/Emacs.ad. These resources are consulted only if no | |
114 app-defaults file is found at all. | |
115 */ | |
116 #include <Emacs.ad.h> | |
117 0 | |
118 }; | |
119 | |
120 static Lisp_Object x_keysym_to_emacs_keysym (KeySym keysym, int simple_p); | |
121 void emacs_Xt_mapping_action (Widget w, XEvent *event); | |
440 | 122 void debug_process_finalization (Lisp_Process *p); |
428 | 123 void emacs_Xt_event_handler (Widget wid, XtPointer closure, XEvent *event, |
124 Boolean *continue_to_dispatch); | |
125 | |
126 static int last_quit_check_signal_tick_count; | |
127 | |
128 Lisp_Object Qsans_modifiers; | |
129 | |
1268 | 130 #define THIS_IS_X |
131 #include "event-xlike-inc.c" | |
132 | |
428 | 133 |
134 /************************************************************************/ | |
135 /* keymap handling */ | |
136 /************************************************************************/ | |
137 | |
2828 | 138 /* See comment near character_to_event(). */ |
440 | 139 static void |
2828 | 140 maybe_define_x_key_as_self_inserting_character (KeySym keysym, |
141 Lisp_Object symbol) | |
440 | 142 { |
143 Lisp_Object character = x_keysym_to_character (keysym); | |
144 | |
145 if (CHARP (character)) | |
146 { | |
147 extern Lisp_Object Vcurrent_global_map; | |
2828 | 148 extern Lisp_Object Qcharacter_of_keysym; |
971 | 149 if (NILP (Flookup_key (Vcurrent_global_map, symbol, Qnil))) |
150 { | |
2828 | 151 Fput (symbol, Qcharacter_of_keysym, character); |
971 | 152 Fdefine_key (Vcurrent_global_map, symbol, Qself_insert_command); |
153 } | |
440 | 154 } |
155 } | |
156 | |
2828 | 157 void |
440 | 158 x_has_keysym (KeySym keysym, Lisp_Object hash_table, int with_modifiers) |
159 { | |
160 KeySym upper_lower[2]; | |
161 int j; | |
162 | |
163 if (keysym < 0x80) /* Optimize for ASCII keysyms */ | |
164 return; | |
442 | 165 |
166 /* If you execute: | |
167 xmodmap -e 'keysym NN = scaron' | |
440 | 168 and then press (Shift scaron), X11 will return the different |
442 | 169 keysym `Scaron', but `xmodmap -pke' might not even mention `Scaron'. |
170 So we "register" both `scaron' and `Scaron'. */ | |
171 #ifdef HAVE_XCONVERTCASE | |
440 | 172 XConvertCase (keysym, &upper_lower[0], &upper_lower[1]); |
442 | 173 #else |
174 upper_lower[0] = upper_lower[1] = keysym; | |
175 #endif | |
440 | 176 |
177 for (j = 0; j < (upper_lower[0] == upper_lower[1] ? 1 : 2); j++) | |
178 { | |
2828 | 179 Extbyte *name; |
440 | 180 keysym = upper_lower[j]; |
181 | |
182 name = XKeysymToString (keysym); | |
183 if (name) | |
184 { | |
185 /* X guarantees NAME to be in the Host Portable Character Encoding */ | |
186 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym, 0); | |
187 Lisp_Object new_value = with_modifiers ? Qt : Qsans_modifiers; | |
188 Lisp_Object old_value = Fgethash (sym, hash_table, Qnil); | |
189 | |
190 if (! EQ (old_value, new_value) | |
191 && ! (EQ (old_value, Qsans_modifiers) && | |
192 EQ (new_value, Qt))) | |
193 { | |
194 maybe_define_x_key_as_self_inserting_character (keysym, sym); | |
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
195 Fputhash (build_extstring (name, Qbinary), new_value, |
2828 | 196 hash_table); |
440 | 197 Fputhash (sym, new_value, hash_table); |
198 } | |
199 } | |
200 } | |
201 } | |
202 | |
428 | 203 static void |
204 x_reset_key_mapping (struct device *d) | |
205 { | |
206 Display *display = DEVICE_X_DISPLAY (d); | |
207 struct x_device *xd = DEVICE_X_DATA (d); | |
208 KeySym *keysym, *keysym_end; | |
209 Lisp_Object hash_table; | |
210 int key_code_count, keysyms_per_code; | |
211 | |
212 if (xd->x_keysym_map) | |
213 XFree ((char *) xd->x_keysym_map); | |
214 XDisplayKeycodes (display, | |
215 &xd->x_keysym_map_min_code, | |
216 &xd->x_keysym_map_max_code); | |
217 key_code_count = xd->x_keysym_map_max_code - xd->x_keysym_map_min_code + 1; | |
218 xd->x_keysym_map = | |
219 XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count, | |
220 &xd->x_keysym_map_keysyms_per_code); | |
221 | |
222 hash_table = xd->x_keysym_map_hash_table; | |
223 if (HASH_TABLEP (hash_table)) | |
224 Fclrhash (hash_table); | |
225 else | |
226 xd->x_keysym_map_hash_table = hash_table = | |
227 make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL); | |
228 | |
229 for (keysym = xd->x_keysym_map, | |
230 keysyms_per_code = xd->x_keysym_map_keysyms_per_code, | |
231 keysym_end = keysym + (key_code_count * keysyms_per_code); | |
232 keysym < keysym_end; | |
233 keysym += keysyms_per_code) | |
234 { | |
235 int j; | |
236 | |
237 if (keysym[0] == NoSymbol) | |
238 continue; | |
239 | |
440 | 240 x_has_keysym (keysym[0], hash_table, 0); |
428 | 241 |
242 for (j = 1; j < keysyms_per_code; j++) | |
243 { | |
244 if (keysym[j] != keysym[0] && | |
245 keysym[j] != NoSymbol) | |
440 | 246 x_has_keysym (keysym[j], hash_table, 1); |
428 | 247 } |
248 } | |
249 } | |
250 | |
2828 | 251 static const Ascbyte * |
428 | 252 index_to_name (int indice) |
253 { | |
254 switch (indice) | |
255 { | |
256 case ShiftMapIndex: return "ModShift"; | |
257 case LockMapIndex: return "ModLock"; | |
258 case ControlMapIndex: return "ModControl"; | |
259 case Mod1MapIndex: return "Mod1"; | |
260 case Mod2MapIndex: return "Mod2"; | |
261 case Mod3MapIndex: return "Mod3"; | |
262 case Mod4MapIndex: return "Mod4"; | |
263 case Mod5MapIndex: return "Mod5"; | |
264 default: return "???"; | |
265 } | |
266 } | |
267 | |
2828 | 268 /* X bogusly doesn't define the interpretations of any bits besides |
269 ModControl, ModShift, and ModLock; so the Interclient Communication | |
270 Conventions Manual says that we have to bend over backwards to figure | |
271 out what the other modifier bits mean. According to ICCCM: | |
272 | |
273 - Any keycode which is assigned ModControl is a "control" key. | |
274 | |
275 - Any modifier bit which is assigned to a keycode which generates Meta_L | |
276 or Meta_R is the modifier bit meaning "meta". Likewise for Super, Hyper, | |
277 etc. | |
278 | |
279 - Any keypress event which contains ModControl in its state should be | |
280 interpreted as a "control" character. | |
281 | |
282 - Any keypress event which contains a modifier bit in its state which is | |
283 generated by a keycode whose corresponding keysym is Meta_L or Meta_R | |
284 should be interpreted as a "meta" character. Likewise for Super, Hyper, | |
285 etc. | |
286 | |
287 - It is illegal for a keysym to be associated with more than one modifier | |
288 bit. | |
289 | |
290 This means that the only thing that emacs can reasonably interpret as a | |
291 "meta" key is a key whose keysym is Meta_L or Meta_R, and which generates | |
292 one of the modifier bits Mod1-Mod5. | |
293 | |
294 Unfortunately, many keyboards don't have Meta keys in their default | |
295 configuration. So, if there are no Meta keys, but there are "Alt" keys, | |
296 emacs will interpret Alt as Meta. If there are both Meta and Alt keys, | |
297 then the Meta keys mean "Meta", and the Alt keys mean "Alt" (it used to | |
298 mean "Symbol," but that just confused the hell out of way too many people). | |
299 | |
300 This works with the default configurations of the 19 keyboard-types I've | |
301 checked. | |
302 | |
303 Emacs detects keyboard configurations which violate the above rules, and | |
304 gives a warning. */ | |
428 | 305 |
306 static void | |
307 x_reset_modifier_mapping (struct device *d) | |
308 { | |
309 Display *display = DEVICE_X_DISPLAY (d); | |
310 struct x_device *xd = DEVICE_X_DATA (d); | |
311 int modifier_index, modifier_key, column, mkpm; | |
312 int warned_about_overlapping_modifiers = 0; | |
313 int warned_about_predefined_modifiers = 0; | |
314 int warned_about_duplicate_modifiers = 0; | |
315 int meta_bit = 0; | |
316 int hyper_bit = 0; | |
317 int super_bit = 0; | |
318 int alt_bit = 0; | |
319 int mode_bit = 0; | |
320 | |
321 xd->lock_interpretation = 0; | |
322 | |
323 if (xd->x_modifier_keymap) | |
3949 | 324 { |
325 XFreeModifiermap (xd->x_modifier_keymap); | |
326 /* Set it to NULL in case we receive two MappingModifier events in a | |
327 row, and the second is processed during some CHECK_QUITs within | |
328 x_reset_key_mapping. If that happens, XFreeModifierMap will be | |
329 called twice on the same map, and we crash. */ | |
330 xd->x_modifier_keymap = NULL; | |
331 } | |
428 | 332 |
333 x_reset_key_mapping (d); | |
334 | |
335 xd->x_modifier_keymap = XGetModifierMapping (display); | |
336 | |
337 /* Boy, I really wish C had local functions... | |
338 */ | |
339 | |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
340 #define modwarn(name,old,other) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
341 warn_when_safe (Qkey_mapping, Qwarning, \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
342 "XEmacs: %s (0x%x) generates %s, which is generated by %s.", \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
343 name, code, index_to_name (old), other), \ |
428 | 344 warned_about_overlapping_modifiers = 1 |
345 | |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
346 #define modbarf(name,other) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
347 warn_when_safe (Qkey_mapping, Qwarning, \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
348 "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
349 name, code, other), \ |
428 | 350 warned_about_predefined_modifiers = 1 |
351 | |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
352 #define check_modifier(name,mask) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
353 if ((1<<modifier_index) != mask) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
354 warn_when_safe (Qkey_mapping, Qwarning, \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
355 "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
356 name, code, index_to_name (modifier_index)), \ |
428 | 357 warned_about_predefined_modifiers = 1 |
358 | |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
359 #define store_modifier(name,old) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
360 if (old && old != modifier_index) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
361 warn_when_safe (Qkey_mapping, Qwarning, \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
362 "XEmacs: %s (0x%x) generates both %s and %s, which is nonsensical.", \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
363 name, code, index_to_name (old), \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
364 index_to_name (modifier_index)), \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
365 warned_about_duplicate_modifiers = 1; \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
366 if (modifier_index == ShiftMapIndex) modbarf (name,"ModShift"); \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
367 else if (modifier_index == LockMapIndex) modbarf (name,"ModLock"); \ |
428 | 368 else if (modifier_index == ControlMapIndex) modbarf (name,"ModControl"); \ |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
369 else if (sym == XK_Mode_switch) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
370 mode_bit = modifier_index; /* Mode_switch is special, see below... */ \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
371 else if (modifier_index == meta_bit && old != meta_bit) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
372 modwarn (name, meta_bit, "Meta"); \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
373 else if (modifier_index == super_bit && old != super_bit) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
374 modwarn (name, super_bit, "Super"); \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
375 else if (modifier_index == hyper_bit && old != hyper_bit) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
376 modwarn (name, hyper_bit, "Hyper"); \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
377 else if (modifier_index == alt_bit && old != alt_bit) \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
378 modwarn (name, alt_bit, "Alt"); \ |
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
379 else \ |
428 | 380 old = modifier_index; |
381 | |
382 mkpm = xd->x_modifier_keymap->max_keypermod; | |
383 for (modifier_index = 0; modifier_index < 8; modifier_index++) | |
384 for (modifier_key = 0; modifier_key < mkpm; modifier_key++) { | |
385 KeySym last_sym = 0; | |
386 for (column = 0; column < 4; column += 2) { | |
387 KeyCode code = xd->x_modifier_keymap->modifiermap[modifier_index * mkpm | |
388 + modifier_key]; | |
389 KeySym sym = (code ? XKeycodeToKeysym (display, code, column) : 0); | |
390 if (sym == last_sym) continue; | |
391 last_sym = sym; | |
392 switch (sym) { | |
393 case XK_Mode_switch:store_modifier ("Mode_switch", mode_bit); break; | |
394 case XK_Meta_L: store_modifier ("Meta_L", meta_bit); break; | |
395 case XK_Meta_R: store_modifier ("Meta_R", meta_bit); break; | |
396 case XK_Super_L: store_modifier ("Super_L", super_bit); break; | |
397 case XK_Super_R: store_modifier ("Super_R", super_bit); break; | |
398 case XK_Hyper_L: store_modifier ("Hyper_L", hyper_bit); break; | |
399 case XK_Hyper_R: store_modifier ("Hyper_R", hyper_bit); break; | |
400 case XK_Alt_L: store_modifier ("Alt_L", alt_bit); break; | |
401 case XK_Alt_R: store_modifier ("Alt_R", alt_bit); break; | |
402 case XK_Control_L: check_modifier ("Control_L", ControlMask); break; | |
403 case XK_Control_R: check_modifier ("Control_R", ControlMask); break; | |
404 case XK_Shift_L: check_modifier ("Shift_L", ShiftMask); break; | |
405 case XK_Shift_R: check_modifier ("Shift_R", ShiftMask); break; | |
406 case XK_Shift_Lock: check_modifier ("Shift_Lock", LockMask); | |
407 xd->lock_interpretation = XK_Shift_Lock; break; | |
408 case XK_Caps_Lock: check_modifier ("Caps_Lock", LockMask); | |
409 xd->lock_interpretation = XK_Caps_Lock; break; | |
410 | |
411 /* It probably doesn't make any sense for a modifier bit to be | |
412 assigned to a key that is not one of the above, but OpenWindows | |
413 assigns modifier bits to a couple of random function keys for | |
414 no reason that I can discern, so printing a warning here would | |
415 be annoying. */ | |
416 } | |
417 } | |
418 } | |
419 #undef store_modifier | |
420 #undef check_modifier | |
421 #undef modwarn | |
422 #undef modbarf | |
423 | |
424 /* If there was no Meta key, then try using the Alt key instead. | |
425 If there is both a Meta key and an Alt key, then the Alt key | |
426 is not disturbed and remains an Alt key. */ | |
427 if (! meta_bit && alt_bit) | |
428 meta_bit = alt_bit, alt_bit = 0; | |
429 | |
430 /* mode_bit overrides everything, since it's processed down inside of | |
431 XLookupString() instead of by us. If Meta and Mode_switch both | |
432 generate the same modifier bit (which is an error), then we don't | |
433 interpret that bit as Meta, because we can't make XLookupString() | |
434 not interpret it as Mode_switch; and interpreting it as both would | |
435 be totally wrong. */ | |
436 if (mode_bit) | |
437 { | |
2828 | 438 const Ascbyte *warn = 0; |
428 | 439 if (mode_bit == meta_bit) warn = "Meta", meta_bit = 0; |
440 else if (mode_bit == hyper_bit) warn = "Hyper", hyper_bit = 0; | |
441 else if (mode_bit == super_bit) warn = "Super", super_bit = 0; | |
442 else if (mode_bit == alt_bit) warn = "Alt", alt_bit = 0; | |
443 if (warn) | |
444 { | |
445 warn_when_safe | |
446 (Qkey_mapping, Qwarning, | |
447 "XEmacs: %s is being used for both Mode_switch and %s.", | |
448 index_to_name (mode_bit), warn), | |
449 warned_about_overlapping_modifiers = 1; | |
450 } | |
451 } | |
452 #undef index_to_name | |
453 | |
454 xd->MetaMask = (meta_bit ? (1 << meta_bit) : 0); | |
455 xd->HyperMask = (hyper_bit ? (1 << hyper_bit) : 0); | |
456 xd->SuperMask = (super_bit ? (1 << super_bit) : 0); | |
457 xd->AltMask = (alt_bit ? (1 << alt_bit) : 0); | |
458 xd->ModeMask = (mode_bit ? (1 << mode_bit) : 0); /* unused */ | |
459 | |
460 | |
461 if (warned_about_overlapping_modifiers) | |
462 warn_when_safe (Qkey_mapping, Qwarning, "\n" | |
463 " Two distinct modifier keys (such as Meta and Hyper) cannot generate\n" | |
464 " the same modifier bit, because Emacs won't be able to tell which\n" | |
465 " modifier was actually held down when some other key is pressed. It\n" | |
466 " won't be able to tell Meta-x and Hyper-x apart, for example. Change\n" | |
467 " one of these keys to use some other modifier bit. If you intend for\n" | |
468 " these keys to have the same behavior, then change them to have the\n" | |
469 " same keysym as well as the same modifier bit."); | |
470 | |
471 if (warned_about_predefined_modifiers) | |
472 warn_when_safe (Qkey_mapping, Qwarning, "\n" | |
473 " The semantics of the modifier bits ModShift, ModLock, and ModControl\n" | |
474 " are predefined. It does not make sense to assign ModControl to any\n" | |
475 " keysym other than Control_L or Control_R, or to assign any modifier\n" | |
476 " bits to the \"control\" keysyms other than ModControl. You can't\n" | |
477 " turn a \"control\" key into a \"meta\" key (or vice versa) by simply\n" | |
478 " assigning the key a different modifier bit. You must also make that\n" | |
479 " key generate an appropriate keysym (Control_L, Meta_L, etc)."); | |
480 | |
481 /* No need to say anything more for warned_about_duplicate_modifiers. */ | |
482 | |
483 if (warned_about_overlapping_modifiers || warned_about_predefined_modifiers) | |
484 warn_when_safe (Qkey_mapping, Qwarning, "\n" | |
485 " The meanings of the modifier bits Mod1 through Mod5 are determined\n" | |
486 " by the keysyms used to control those bits. Mod1 does NOT always\n" | |
487 " mean Meta, although some non-ICCCM-compliant programs assume that."); | |
488 } | |
489 | |
490 void | |
491 x_init_modifier_mapping (struct device *d) | |
492 { | |
493 struct x_device *xd = DEVICE_X_DATA (d); | |
494 xd->x_keysym_map_hash_table = Qnil; | |
495 xd->x_keysym_map = NULL; | |
496 xd->x_modifier_keymap = NULL; | |
497 x_reset_modifier_mapping (d); | |
498 } | |
499 | |
500 static int | |
501 x_key_is_modifier_p (KeyCode keycode, struct device *d) | |
502 { | |
503 struct x_device *xd = DEVICE_X_DATA (d); | |
504 KeySym *syms; | |
505 int i; | |
506 | |
507 if (keycode < xd->x_keysym_map_min_code || | |
508 keycode > xd->x_keysym_map_max_code) | |
509 return 0; | |
510 | |
511 syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) * | |
512 xd->x_keysym_map_keysyms_per_code]; | |
513 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++) | |
514 if (IsModifierKey (syms [i]) || | |
515 syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */ | |
516 return 1; | |
517 return 0; | |
518 } | |
519 | |
520 /* key-handling code is always ugly. It just ends up working out | |
521 that way. | |
522 | |
523 Here are some pointers: | |
524 | |
525 -- DOWN_MASK indicates which modifiers should be treated as "down" | |
526 when the corresponding upstroke happens. It gets reset for | |
527 a particular modifier when that modifier goes up, and reset | |
528 for all modifiers when a non-modifier key is pressed. Example: | |
529 | |
530 I press Control-A-Shift and then release Control-A-Shift. | |
531 I want the Shift key to be sticky but not the Control key. | |
532 | |
533 -- LAST_DOWNKEY and RELEASE_TIME are used to keep track of | |
534 auto-repeat -- see below. | |
535 | |
536 -- If a modifier key is sticky, I can unstick it by pressing | |
537 the modifier key again. */ | |
538 | |
539 static void | |
540 x_handle_sticky_modifiers (XEvent *ev, struct device *d) | |
541 { | |
542 struct x_device *xd; | |
543 KeyCode keycode; | |
544 int type; | |
545 | |
546 if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */ | |
547 return; | |
548 | |
549 xd = DEVICE_X_DATA (d); | |
550 keycode = ev->xkey.keycode; | |
551 type = ev->type; | |
552 | |
553 if (keycode < xd->x_keysym_map_min_code || | |
554 keycode > xd->x_keysym_map_max_code) | |
555 return; | |
556 | |
557 if (! ((type == KeyPress || type == KeyRelease) && | |
558 x_key_is_modifier_p (keycode, d))) | |
559 { /* Not a modifier key */ | |
560 Bool key_event_p = (type == KeyPress || type == KeyRelease); | |
561 | |
444 | 562 if (type == ButtonPress |
563 || (type == KeyPress | |
564 && ((xd->last_downkey | |
565 && ((keycode != xd->last_downkey | |
566 || ev->xkey.time != xd->release_time))) | |
567 || (INTP (Vmodifier_keys_sticky_time) | |
568 && ev->xkey.time | |
569 > (xd->modifier_release_time | |
570 + XINT (Vmodifier_keys_sticky_time)))))) | |
428 | 571 { |
572 xd->need_to_add_mask = 0; | |
573 xd->last_downkey = 0; | |
574 } | |
444 | 575 else if (type == KeyPress && !xd->last_downkey) |
576 xd->last_downkey = keycode; | |
577 | |
428 | 578 if (type == KeyPress) |
579 xd->release_time = 0; | |
580 if (type == KeyPress || type == ButtonPress) | |
444 | 581 { |
582 xd->down_mask = 0; | |
583 xd->modifier_release_time = 0; | |
584 } | |
428 | 585 |
586 if (key_event_p) | |
587 ev->xkey.state |= xd->need_to_add_mask; | |
588 else | |
589 ev->xbutton.state |= xd->need_to_add_mask; | |
590 | |
591 if (type == KeyRelease && keycode == xd->last_downkey) | |
592 /* If I hold press-and-release the Control key and then press | |
593 and hold down the right arrow, I want it to auto-repeat | |
594 Control-Right. On the other hand, if I do the same but | |
595 manually press the Right arrow a bunch of times, I want | |
596 to see one Control-Right and then a bunch of Rights. | |
597 This means that we need to distinguish between an | |
598 auto-repeated key and a key pressed and released a bunch | |
599 of times. | |
600 | |
601 Naturally, the designers of the X spec didn't see fit | |
602 to provide an obvious way to distinguish these cases. | |
603 So we assume that if the release and the next press | |
604 occur at the same time, the key was actually auto- | |
605 repeated. Under Open-Windows, at least, this works. */ | |
444 | 606 xd->modifier_release_time = xd->release_time |
607 = key_event_p ? ev->xkey.time : ev->xbutton.time; | |
428 | 608 } |
609 else /* Modifier key pressed */ | |
610 { | |
611 int i; | |
612 KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) * | |
613 xd->x_keysym_map_keysyms_per_code]; | |
614 | |
615 /* If a non-modifier key was pressed in the middle of a bunch | |
616 of modifiers, then it unsticks all the modifiers that were | |
617 previously pressed. We cannot unstick the modifiers until | |
618 now because we want to check for auto-repeat of the | |
619 non-modifier key. */ | |
620 | |
621 if (xd->last_downkey) | |
622 { | |
623 xd->last_downkey = 0; | |
624 xd->need_to_add_mask = 0; | |
625 } | |
626 | |
444 | 627 if (xd->modifier_release_time |
628 && INTP (Vmodifier_keys_sticky_time) | |
629 && (ev->xkey.time | |
630 > xd->modifier_release_time + XINT (Vmodifier_keys_sticky_time))) | |
631 { | |
632 xd->need_to_add_mask = 0; | |
633 xd->down_mask = 0; | |
634 } | |
635 | |
428 | 636 #define FROB(mask) \ |
637 do { \ | |
638 if (type == KeyPress) \ | |
639 { \ | |
640 /* If modifier key is already sticky, \ | |
641 then unstick it. Note that we do \ | |
642 not test down_mask to deal with the \ | |
643 unlikely but possible case that the \ | |
644 modifier key auto-repeats. */ \ | |
645 if (xd->need_to_add_mask & mask) \ | |
646 { \ | |
647 xd->need_to_add_mask &= ~mask; \ | |
648 xd->down_mask &= ~mask; \ | |
649 } \ | |
650 else \ | |
651 xd->down_mask |= mask; \ | |
652 } \ | |
653 else \ | |
654 { \ | |
655 if (xd->down_mask & mask) \ | |
656 { \ | |
657 xd->down_mask &= ~mask; \ | |
658 xd->need_to_add_mask |= mask; \ | |
659 } \ | |
660 } \ | |
444 | 661 xd->modifier_release_time = ev->xkey.time; \ |
428 | 662 } while (0) |
663 | |
664 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++) | |
665 switch (syms[i]) | |
666 { | |
667 case XK_Control_L: case XK_Control_R: FROB (ControlMask); break; | |
668 case XK_Shift_L: case XK_Shift_R: FROB (ShiftMask); break; | |
669 case XK_Meta_L: case XK_Meta_R: FROB (xd->MetaMask); break; | |
670 case XK_Super_L: case XK_Super_R: FROB (xd->SuperMask); break; | |
671 case XK_Hyper_L: case XK_Hyper_R: FROB (xd->HyperMask); break; | |
672 case XK_Alt_L: case XK_Alt_R: FROB (xd->AltMask); break; | |
673 } | |
674 } | |
675 #undef FROB | |
676 } | |
677 | |
678 static void | |
679 clear_sticky_modifiers (struct device *d) | |
680 { | |
681 struct x_device *xd = DEVICE_X_DATA (d); | |
682 | |
683 xd->need_to_add_mask = 0; | |
684 xd->last_downkey = 0; | |
685 xd->release_time = 0; | |
686 xd->down_mask = 0; | |
687 } | |
688 | |
689 static int | |
690 keysym_obeys_caps_lock_p (KeySym sym, struct device *d) | |
691 { | |
692 struct x_device *xd = DEVICE_X_DATA (d); | |
693 /* Eeeeevil hack. Don't apply Caps_Lock to things that aren't alphabetic | |
694 characters, where "alphabetic" means something more than simply A-Z. | |
695 That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC. | |
696 But if shift-lock is down, then it does. */ | |
697 if (xd->lock_interpretation == XK_Shift_Lock) | |
698 return 1; | |
699 | |
700 return | |
701 ((sym >= XK_A) && (sym <= XK_Z)) || | |
702 ((sym >= XK_a) && (sym <= XK_z)) || | |
703 ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) || | |
704 ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) || | |
705 ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) || | |
706 ((sym >= XK_oslash) && (sym <= XK_thorn)); | |
707 } | |
708 | |
709 /* called from EmacsFrame.c (actually from Xt itself) when a | |
710 MappingNotify event is received. In its infinite wisdom, Xt | |
711 decided that Xt event handlers never get MappingNotify events. | |
712 O'Reilly Xt Programming Manual 9.1.2 says: | |
713 | |
714 MappingNotify is automatically handled by Xt, so it isn't passed | |
715 to event handlers and you don't need to worry about it. | |
716 | |
717 Of course, we DO worry about it, so we need a special translation. */ | |
718 void | |
2286 | 719 emacs_Xt_mapping_action (Widget UNUSED (w), XEvent *event) |
428 | 720 { |
721 struct device *d = get_device_from_display (event->xany.display); | |
722 | |
723 if (DEVICE_X_BEING_DELETED (d)) | |
724 return; | |
725 #if 0 | |
726 /* nyet. Now this is handled by Xt. */ | |
727 XRefreshKeyboardMapping (&event->xmapping); | |
728 #endif | |
729 /* xmodmap generates about a billion MappingKeyboard events, followed | |
730 by a single MappingModifier event, so it might be worthwhile to | |
731 take extra MappingKeyboard events out of the queue before requesting | |
732 the current keymap from the server. */ | |
733 switch (event->xmapping.request) | |
734 { | |
735 case MappingKeyboard: x_reset_key_mapping (d); break; | |
736 case MappingModifier: x_reset_modifier_mapping (d); break; | |
737 case MappingPointer: /* Do something here? */ break; | |
2500 | 738 default: ABORT(); |
428 | 739 } |
740 } | |
741 | |
742 | |
743 /************************************************************************/ | |
744 /* X to Emacs event conversion */ | |
745 /************************************************************************/ | |
746 | |
747 static Lisp_Object | |
748 x_keysym_to_emacs_keysym (KeySym keysym, int simple_p) | |
749 { | |
2828 | 750 Extbyte *name; |
751 DECLARE_EISTRING(einame); | |
752 | |
428 | 753 if (keysym >= XK_exclam && keysym <= XK_asciitilde) |
754 /* We must assume that the X keysym numbers for the ASCII graphic | |
755 characters are the same as their ASCII codes. */ | |
756 return make_char (keysym); | |
757 | |
758 switch (keysym) | |
759 { | |
760 /* These would be handled correctly by the default case, but by | |
761 special-casing them here we don't garbage a string or call | |
762 intern(). */ | |
763 case XK_BackSpace: return QKbackspace; | |
764 case XK_Tab: return QKtab; | |
765 case XK_Linefeed: return QKlinefeed; | |
766 case XK_Return: return QKreturn; | |
767 case XK_Escape: return QKescape; | |
768 case XK_space: return QKspace; | |
769 case XK_Delete: return QKdelete; | |
770 case 0: return Qnil; | |
771 default: | |
772 if (simple_p) return Qnil; | |
773 name = XKeysymToString (keysym); | |
774 if (!name || !name[0]) | |
775 /* This happens if there is a mismatch between the Xlib of | |
776 XEmacs and the Xlib of the X server... | |
777 | |
778 Let's hard-code in some knowledge of common keysyms introduced | |
779 in recent X11 releases. Snarfed from X11/keysymdef.h | |
780 | |
781 Probably we should add some stuff here for X11R6. */ | |
782 switch (keysym) | |
783 { | |
784 case 0xFF95: return KEYSYM ("kp-home"); | |
785 case 0xFF96: return KEYSYM ("kp-left"); | |
786 case 0xFF97: return KEYSYM ("kp-up"); | |
787 case 0xFF98: return KEYSYM ("kp-right"); | |
788 case 0xFF99: return KEYSYM ("kp-down"); | |
789 case 0xFF9A: return KEYSYM ("kp-prior"); | |
790 case 0xFF9B: return KEYSYM ("kp-next"); | |
791 case 0xFF9C: return KEYSYM ("kp-end"); | |
792 case 0xFF9D: return KEYSYM ("kp-begin"); | |
793 case 0xFF9E: return KEYSYM ("kp-insert"); | |
794 case 0xFF9F: return KEYSYM ("kp-delete"); | |
795 | |
796 case 0x1005FF10: return KEYSYM ("SunF36"); /* labeled F11 */ | |
797 case 0x1005FF11: return KEYSYM ("SunF37"); /* labeled F12 */ | |
798 default: | |
799 { | |
2828 | 800 Ascbyte buf [64]; |
428 | 801 sprintf (buf, "unknown-keysym-0x%X", (int) keysym); |
802 return KEYSYM (buf); | |
803 } | |
804 } | |
2828 | 805 |
428 | 806 /* If it's got a one-character name, that's good enough. */ |
807 if (!name[1]) | |
2828 | 808 return make_char ((Ichar)name[0]); |
809 | |
810 /* In theory the Host Portable Character Set is just ASCII, but | |
811 trusting X11 implementors to get that right is likely to lead to | |
812 tears. */ | |
813 eicpy_ext(einame, name, Qbinary); | |
428 | 814 |
815 /* If it's in the "Keyboard" character set, downcase it. | |
816 The case of those keysyms is too totally random for us to | |
817 force anyone to remember them. | |
2828 | 818 The case of the other character sets is significant, however. */ |
428 | 819 if ((((unsigned int) keysym) & (~0x1FF)) == ((unsigned int) 0xFE00)) |
820 { | |
2828 | 821 Ibyte *iname; |
822 eilwr(einame); | |
823 | |
824 for (iname = eidata(einame); *iname != '\0';) | |
825 { | |
826 if (*iname == '_') | |
827 { | |
828 *iname = '-'; | |
829 } | |
830 INC_IBYTEPTR(iname); | |
428 | 831 } |
832 } | |
2837 | 833 return KEYSYM ((const CIbyte *) eidata (einame)); |
428 | 834 } |
835 } | |
836 | |
837 static Lisp_Object | |
838 x_to_emacs_keysym (XKeyPressedEvent *event, int simple_p) | |
839 /* simple_p means don't try too hard (ASCII only) */ | |
840 { | |
841 KeySym keysym = 0; | |
842 | |
843 #ifdef HAVE_XIM | |
3072 | 844 int len = 0; |
442 | 845 /* Some implementations of XmbLookupString don't return |
846 XBufferOverflow correctly, so increase the size of the xim input | |
847 buffer from 64 to the more reasonable size 513, as Emacs has done. | |
848 From Kenichi Handa. */ | |
849 char buffer[513]; | |
428 | 850 char *bufptr = buffer; |
851 int bufsiz = sizeof (buffer); | |
852 Status status; | |
853 #ifdef XIM_XLIB | |
854 XIC xic = FRAME_X_XIC (x_any_window_to_frame | |
855 (get_device_from_display (event->display), | |
856 event->window)); | |
857 #endif /* XIM_XLIB */ | |
858 #endif /* HAVE_XIM */ | |
859 | |
860 /* We use XLookupString if we're not using XIM, or are using | |
861 XIM_XLIB but input context creation failed. */ | |
862 #if ! (defined (HAVE_XIM) && defined (XIM_MOTIF)) | |
863 #if defined (HAVE_XIM) && defined (XIM_XLIB) | |
864 if (!xic) | |
865 #endif /* XIM_XLIB */ | |
866 { | |
867 /* Apparently it's necessary to specify a dummy here (rather | |
868 than passing in 0) to avoid crashes on German IRIX */ | |
869 char dummy[256]; | |
870 XLookupString (event, dummy, 200, &keysym, 0); | |
871 return (IsModifierKey (keysym) || keysym == XK_Mode_switch ) | |
872 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p); | |
873 } | |
874 #endif /* ! XIM_MOTIF */ | |
875 | |
876 #ifdef HAVE_XIM | |
877 Lookup_String: /* Come-From XBufferOverflow */ | |
878 #ifdef XIM_MOTIF | |
879 len = XmImMbLookupString (XtWindowToWidget (event->display, event->window), | |
880 event, bufptr, bufsiz, &keysym, &status); | |
881 #else /* XIM_XLIB */ | |
882 if (xic) | |
883 len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status); | |
1494 | 884 #endif /* XIM_MOTIF */ |
428 | 885 |
886 #ifdef DEBUG_XEMACS | |
442 | 887 if (debug_x_events > 0) |
428 | 888 { |
889 stderr_out (" status="); | |
890 #define print_status_when(S) if (status == S) stderr_out (#S) | |
891 print_status_when (XLookupKeySym); | |
892 print_status_when (XLookupBoth); | |
893 print_status_when (XLookupChars); | |
894 print_status_when (XLookupNone); | |
895 print_status_when (XBufferOverflow); | |
896 | |
897 if (status == XLookupKeySym || status == XLookupBoth) | |
898 stderr_out (" keysym=%s", XKeysymToString (keysym)); | |
899 if (status == XLookupChars || status == XLookupBoth) | |
900 { | |
3072 | 901 if (len > 1) |
428 | 902 { |
903 int j; | |
904 stderr_out (" chars=\""); | |
905 for (j=0; j<len; j++) | |
3142 | 906 { |
907 if (040 <= bufptr[j] && bufptr[j] >= 0177) | |
908 { | |
909 stderr_out ("%c", bufptr[j]); | |
910 } | |
911 else | |
912 { | |
913 stderr_out ("\\%o", (unsigned)(bufptr[j])); | |
914 } | |
915 } | |
428 | 916 stderr_out ("\""); |
917 } | |
918 else if (bufptr[0] <= 32 || bufptr[0] >= 127) | |
919 stderr_out (" char=0x%x", bufptr[0]); | |
920 else | |
921 stderr_out (" char=%c", bufptr[0]); | |
922 } | |
923 stderr_out ("\n"); | |
924 } | |
925 #endif /* DEBUG_XEMACS */ | |
926 | |
927 switch (status) | |
928 { | |
929 case XLookupKeySym: | |
930 case XLookupBoth: | |
931 return (IsModifierKey (keysym) || keysym == XK_Mode_switch ) | |
932 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p); | |
933 | |
934 case XLookupChars: | |
935 { | |
936 /* Generate multiple emacs events */ | |
937 struct device *d = get_device_from_display (event->display); | |
867 | 938 Ichar ch; |
428 | 939 Lisp_Object instream, fb_instream; |
940 Lstream *istr; | |
941 struct gcpro gcpro1, gcpro2; | |
942 | |
440 | 943 fb_instream = make_fixed_buffer_input_stream (bufptr, len); |
944 | |
3142 | 945 /* [[ Use get_coding_system_for_text_file |
946 (Vcomposed_input_coding_system, 0) ]] | |
947 | |
948 Nope. If it is possible for the X libraries to have multiple IM | |
949 connections on different DISPLAYs active at once, this should be | |
950 a console-specific variable (like a TTY's coding system) but I've | |
951 seen no evidence that that is possible. Aidan Kehoe, | |
952 2005-12-17. */ | |
953 | |
428 | 954 instream = |
771 | 955 make_coding_input_stream |
3142 | 956 (XLSTREAM (fb_instream), Qkeyboard, CODING_DECODE, 0); |
428 | 957 |
958 istr = XLSTREAM (instream); | |
959 | |
960 GCPRO2 (instream, fb_instream); | |
867 | 961 while ((ch = Lstream_get_ichar (istr)) != EOF) |
428 | 962 { |
963 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil); | |
440 | 964 Lisp_Event *ev = XEVENT (emacs_event); |
428 | 965 ev->channel = DEVICE_CONSOLE (d); |
4780
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
966 XSET_EVENT_TYPE (emacs_event, key_press_event); |
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
967 /* Make sure space and linefeed and so on get the proper |
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
968 keysyms. */ |
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
969 character_to_event (ch, ev, XCONSOLE (ev->channel), |
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
970 latin_1_maps_to_itself, 0); |
960 | 971 ev->timestamp = event->time; |
1204 | 972 enqueue_dispatch_event (emacs_event); |
428 | 973 } |
974 Lstream_close (istr); | |
975 UNGCPRO; | |
976 Lstream_delete (istr); | |
977 Lstream_delete (XLSTREAM (fb_instream)); | |
978 return Qnil; | |
979 } | |
980 case XLookupNone: return Qnil; | |
981 case XBufferOverflow: | |
2367 | 982 /* !!#### needs work */ |
851 | 983 bufptr = (char *) ALLOCA (len+1); |
428 | 984 bufsiz = len+1; |
985 goto Lookup_String; | |
986 } | |
801 | 987 return Qnil; /* not (usually) reached */ |
428 | 988 #endif /* HAVE_XIM */ |
989 } | |
990 | |
991 static void | |
992 set_last_server_timestamp (struct device *d, XEvent *x_event) | |
993 { | |
994 Time t; | |
995 switch (x_event->type) | |
996 { | |
997 case KeyPress: | |
998 case KeyRelease: t = x_event->xkey.time; break; | |
999 case ButtonPress: | |
1000 case ButtonRelease: t = x_event->xbutton.time; break; | |
1001 case EnterNotify: | |
1002 case LeaveNotify: t = x_event->xcrossing.time; break; | |
1003 case MotionNotify: t = x_event->xmotion.time; break; | |
1004 case PropertyNotify: t = x_event->xproperty.time; break; | |
1005 case SelectionClear: t = x_event->xselectionclear.time; break; | |
1006 case SelectionRequest: t = x_event->xselectionrequest.time; break; | |
1007 case SelectionNotify: t = x_event->xselection.time; break; | |
1008 default: return; | |
1009 } | |
1010 DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t; | |
1011 } | |
1012 | |
1013 static int | |
440 | 1014 x_event_to_emacs_event (XEvent *x_event, Lisp_Event *emacs_event) |
428 | 1015 { |
1016 Display *display = x_event->xany.display; | |
1017 struct device *d = get_device_from_display (display); | |
1018 struct x_device *xd = DEVICE_X_DATA (d); | |
1019 | |
1020 if (DEVICE_X_BEING_DELETED (d)) | |
2828 | 1021 { |
1022 /* [[ Uh, is this 0 correct? ]] | |
1023 | |
1024 Yup--it means emacs_Xt_event_handler, the only place that calls | |
1025 this, doesn't queue the emacs_event dispatch, instead immediately | |
1026 deallocating it. */ | |
1027 return 0; | |
1028 } | |
428 | 1029 |
1030 set_last_server_timestamp (d, x_event); | |
1031 | |
1032 switch (x_event->type) | |
1033 { | |
1034 case KeyRelease: | |
934 | 1035 { |
1036 x_handle_sticky_modifiers (x_event, d); | |
1037 return 0; | |
1038 } | |
428 | 1039 case KeyPress: |
1040 case ButtonPress: | |
1041 case ButtonRelease: | |
1042 { | |
442 | 1043 int modifiers = 0; |
428 | 1044 int shift_p, lock_p; |
1045 Bool key_event_p = (x_event->type == KeyPress); | |
1046 unsigned int *state = | |
1047 key_event_p ? &x_event->xkey.state : &x_event->xbutton.state; | |
1048 | |
1049 /* If this is a synthetic KeyPress or Button event, and the user | |
1050 has expressed a disinterest in this security hole, then drop | |
1051 it on the floor. */ | |
1052 if ((key_event_p | |
1053 ? x_event->xkey.send_event | |
1054 : x_event->xbutton.send_event) | |
1055 #ifdef EXTERNAL_WIDGET | |
1056 /* ben: events get sent to an ExternalShell using XSendEvent. | |
1057 This is not a perfect solution. */ | |
1058 && !FRAME_X_EXTERNAL_WINDOW_P | |
1059 (x_any_window_to_frame (d, x_event->xany.window)) | |
1060 #endif | |
1061 && !x_allow_sendevents) | |
1062 return 0; | |
1063 | |
1064 DEVICE_X_MOUSE_TIMESTAMP (d) = | |
1065 DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) = | |
1066 key_event_p ? x_event->xkey.time : x_event->xbutton.time; | |
1067 | |
1068 x_handle_sticky_modifiers (x_event, d); | |
1069 | |
442 | 1070 if (*state & ControlMask) modifiers |= XEMACS_MOD_CONTROL; |
1071 if (*state & xd->MetaMask) modifiers |= XEMACS_MOD_META; | |
1072 if (*state & xd->SuperMask) modifiers |= XEMACS_MOD_SUPER; | |
1073 if (*state & xd->HyperMask) modifiers |= XEMACS_MOD_HYPER; | |
1074 if (*state & xd->AltMask) modifiers |= XEMACS_MOD_ALT; | |
1075 { | |
1076 int numero_de_botao = -1; | |
1077 | |
1078 if (!key_event_p) | |
1079 numero_de_botao = x_event->xbutton.button; | |
1080 | |
1081 /* the button gets noted either in the button or the modifiers | |
1082 field, but not both. */ | |
1083 if (numero_de_botao != 1 && (*state & Button1Mask)) | |
1084 modifiers |= XEMACS_MOD_BUTTON1; | |
1085 if (numero_de_botao != 2 && (*state & Button2Mask)) | |
1086 modifiers |= XEMACS_MOD_BUTTON2; | |
1087 if (numero_de_botao != 3 && (*state & Button3Mask)) | |
1088 modifiers |= XEMACS_MOD_BUTTON3; | |
1089 if (numero_de_botao != 4 && (*state & Button4Mask)) | |
1090 modifiers |= XEMACS_MOD_BUTTON4; | |
1091 if (numero_de_botao != 5 && (*state & Button5Mask)) | |
1092 modifiers |= XEMACS_MOD_BUTTON5; | |
1093 } | |
428 | 1094 |
1095 /* Ignore the Caps_Lock key if: | |
1096 - any other modifiers are down, so that Caps_Lock doesn't | |
1097 turn C-x into C-X, which would suck. | |
1098 - the event was a mouse event. */ | |
1099 if (modifiers || ! key_event_p) | |
1100 *state &= (~LockMask); | |
1101 | |
1102 shift_p = *state & ShiftMask; | |
1103 lock_p = *state & LockMask; | |
1104 | |
1105 if (shift_p || lock_p) | |
442 | 1106 modifiers |= XEMACS_MOD_SHIFT; |
428 | 1107 |
1108 if (key_event_p) | |
1109 { | |
1110 Lisp_Object keysym; | |
1111 XKeyEvent *ev = &x_event->xkey; | |
1112 /* This used to compute the frame from the given X window and | |
1113 store it here, but we really don't care about the frame. */ | |
934 | 1114 SET_EVENT_CHANNEL (emacs_event, DEVICE_CONSOLE (d)); |
428 | 1115 keysym = x_to_emacs_keysym (&x_event->xkey, 0); |
1116 | |
1117 /* If the emacs keysym is nil, then that means that the X | |
1118 keysym was either a Modifier or NoSymbol, which | |
1119 probably means that we're in the midst of reading a | |
1120 Multi_key sequence, or a "dead" key prefix, or XIM | |
1121 input. Ignore it. */ | |
1122 if (NILP (keysym)) | |
1123 return 0; | |
1124 | |
3171 | 1125 /* If we have the map from keycodes to the US layout for our |
1126 keyboard available, store the US layout interpretation of | |
1127 that key in the event structure, in case a binding lookup | |
1128 fails and we want to fall back to the US layout binding. | |
1129 | |
1130 This _might_ be possible within an XKB framework, changing | |
1131 the keyboard to a US XKB layout for a moment at startup, | |
1132 storing the correspondance, and changing it back. But that | |
1133 won't work on non-XKB servers, it makes our already slow | |
1134 startup slower, and it's not clear that it's really any | |
1135 easier or more maintainable than storing a correspondence in | |
1136 Lisp. */ | |
1137 | |
1138 if (!NILP(Vx_us_keymap_description) && | |
1139 VECTORP(Vx_us_keymap_description) && | |
1140 ev->keycode >= (unsigned)Vx_us_keymap_first_keycode && | |
1141 ev->keycode | |
1142 < (unsigned)XVECTOR_LENGTH(Vx_us_keymap_description)) | |
1143 { | |
1144 Lisp_Object entr = XVECTOR_DATA(Vx_us_keymap_description) | |
1145 [ev->keycode - Vx_us_keymap_first_keycode]; | |
1146 Ichar alternate = '\0'; | |
1147 | |
1148 if (!NILP (entr)) | |
1149 { | |
1150 if (CHARP(entr)) | |
1151 { | |
1152 alternate = XCHAR(entr); | |
1153 } | |
1154 else if (VECTORP(entr)) | |
1155 { | |
1156 if (modifiers & XEMACS_MOD_SHIFT | |
1157 && XVECTOR_LENGTH(Vx_us_keymap_description) > 1) | |
1158 { | |
1159 entr = XVECTOR_DATA(entr)[1]; | |
1160 if (CHARP(entr)) | |
1161 { | |
1162 alternate = XCHAR(entr); | |
1163 } | |
1164 } | |
1165 else if (XVECTOR_LENGTH(Vx_us_keymap_description) | |
1166 > 0) | |
1167 { | |
1168 entr = XVECTOR_DATA(entr)[0]; | |
1169 if (CHARP(entr)) | |
1170 { | |
1171 alternate = XCHAR(entr); | |
1172 } | |
1173 } | |
1174 } | |
1175 if ('\0' != alternate) | |
1176 { | |
1177 SET_EVENT_KEY_ALT_KEYCHARS(emacs_event, KEYCHAR_QWERTY, | |
1178 alternate); | |
1179 } | |
1180 } | |
1181 } | |
1182 | |
428 | 1183 /* More Caps_Lock garbage: Caps_Lock should *only* add the |
1184 shift modifier to two-case keys (that is, A-Z and | |
1185 related characters). So at this point (after looking up | |
1186 the keysym) if the keysym isn't a dual-case alphabetic, | |
1187 and if the caps lock key was down but the shift key | |
1188 wasn't, then turn off the shift modifier. Gag barf */ | |
2828 | 1189 |
428 | 1190 /* #### type lossage: assuming equivalence of emacs and |
2828 | 1191 X keysyms |
1192 | |
1193 The right thing to do here is to have pass a third, pointer, | |
1194 argument to x_to_emacs_keysym, where it should store the | |
1195 intermediate KeySym it used to calculate the string XEmacs | |
1196 keysym. Then we can call keysym_obeys_caps_lock_p with | |
1197 exactly the right argument. */ | |
3171 | 1198 |
2828 | 1199 /* !!#### maybe fix for Mule |
1200 | |
1201 Hard, in the absence of a full case infrastructure for | |
1202 Mule characters. When | |
1203 (downcase (make-char 'cyrillic-iso8859-5 73)) | |
1204 works, we should revisit it. */ | |
1205 | |
428 | 1206 if (lock_p && !shift_p && |
1207 ! (CHAR_OR_CHAR_INTP (keysym) | |
1208 && keysym_obeys_caps_lock_p | |
1209 ((KeySym) XCHAR_OR_CHAR_INT (keysym), d))) | |
442 | 1210 modifiers &= (~XEMACS_MOD_SHIFT); |
428 | 1211 |
1212 /* If this key contains two distinct keysyms, that is, | |
1213 "shift" generates a different keysym than the | |
1214 non-shifted key, then don't apply the shift modifier | |
1215 bit: it's implicit. Otherwise, if there would be no | |
1216 other way to tell the difference between the shifted | |
1217 and unshifted version of this key, apply the shift bit. | |
1218 Non-graphics, like Backspace and F1 get the shift bit | |
1219 in the modifiers slot. Neither the characters "a", | |
1220 "A", "2", nor "@" normally have the shift bit set. | |
1221 However, "F1" normally does. */ | |
3171 | 1222 |
442 | 1223 if (modifiers & XEMACS_MOD_SHIFT) |
428 | 1224 { |
1225 int Mode_switch_p = *state & xd->ModeMask; | |
1226 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0); | |
1227 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1); | |
1228 if (top && bot && top != bot) | |
442 | 1229 modifiers &= ~XEMACS_MOD_SHIFT; |
428 | 1230 } |
934 | 1231 set_event_type (emacs_event, key_press_event); |
1232 SET_EVENT_TIMESTAMP (emacs_event, ev->time); | |
1204 | 1233 SET_EVENT_KEY_MODIFIERS (emacs_event, modifiers); |
1234 SET_EVENT_KEY_KEYSYM (emacs_event, keysym); | |
428 | 1235 } |
1236 else /* Mouse press/release event */ | |
1237 { | |
1238 XButtonEvent *ev = &x_event->xbutton; | |
1239 struct frame *frame = x_window_to_frame (d, ev->window); | |
1240 | |
1241 if (! frame) | |
1242 return 0; /* not for us */ | |
934 | 1243 set_event_type (emacs_event, (x_event->type == ButtonPress) ? |
1244 button_press_event : button_release_event); | |
1204 | 1245 SET_EVENT_CHANNEL (emacs_event, wrap_frame (frame)); |
1246 | |
1247 SET_EVENT_BUTTON_MODIFIERS (emacs_event, modifiers); | |
934 | 1248 SET_EVENT_TIMESTAMP (emacs_event, ev->time); |
1204 | 1249 SET_EVENT_BUTTON_BUTTON (emacs_event, ev->button); |
1250 SET_EVENT_BUTTON_X (emacs_event, ev->x); | |
1251 SET_EVENT_BUTTON_Y (emacs_event, ev->y); | |
428 | 1252 /* because we don't seem to get a FocusIn event for button clicks |
1253 when a widget-glyph is selected we will assume that we want the | |
1254 focus if a button gets pressed. */ | |
1255 if (x_event->type == ButtonPress) | |
1256 handle_focus_event_1 (frame, 1); | |
1257 } | |
1258 } | |
1259 break; | |
1260 | |
1261 case MotionNotify: | |
1262 { | |
1263 XMotionEvent *ev = &x_event->xmotion; | |
1264 struct frame *frame = x_window_to_frame (d, ev->window); | |
442 | 1265 int modifiers = 0; |
428 | 1266 XMotionEvent event2; |
1267 | |
1268 if (! frame) | |
1269 return 0; /* not for us */ | |
1270 | |
1271 /* We use MotionHintMask, so we will get only one motion event | |
1272 until the next time we call XQueryPointer or the user | |
1273 clicks the mouse. So call XQueryPointer now (meaning that | |
1274 the event will be in sync with the server just before | |
1275 Fnext_event() returns). If the mouse is still in motion, | |
1276 then the server will immediately generate exactly one more | |
1277 motion event, which will be on the queue waiting for us | |
1278 next time around. */ | |
1279 event2 = *ev; | |
1280 if (XQueryPointer (event2.display, event2.window, | |
1281 &event2.root, &event2.subwindow, | |
1282 &event2.x_root, &event2.y_root, | |
1283 &event2.x, &event2.y, | |
1284 &event2.state)) | |
1285 ev = &event2; /* only one structure copy */ | |
1286 | |
1287 DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time; | |
1204 | 1288 SET_EVENT_CHANNEL (emacs_event, wrap_frame (frame)); |
934 | 1289 set_event_type (emacs_event, pointer_motion_event); |
1290 SET_EVENT_TIMESTAMP (emacs_event, ev->time); | |
1204 | 1291 SET_EVENT_MOTION_X (emacs_event, ev->x); |
1292 SET_EVENT_MOTION_Y (emacs_event, ev->y); | |
442 | 1293 if (ev->state & ShiftMask) modifiers |= XEMACS_MOD_SHIFT; |
1294 if (ev->state & ControlMask) modifiers |= XEMACS_MOD_CONTROL; | |
1295 if (ev->state & xd->MetaMask) modifiers |= XEMACS_MOD_META; | |
1296 if (ev->state & xd->SuperMask) modifiers |= XEMACS_MOD_SUPER; | |
1297 if (ev->state & xd->HyperMask) modifiers |= XEMACS_MOD_HYPER; | |
1298 if (ev->state & xd->AltMask) modifiers |= XEMACS_MOD_ALT; | |
1299 if (ev->state & Button1Mask) modifiers |= XEMACS_MOD_BUTTON1; | |
1300 if (ev->state & Button2Mask) modifiers |= XEMACS_MOD_BUTTON2; | |
1301 if (ev->state & Button3Mask) modifiers |= XEMACS_MOD_BUTTON3; | |
1302 if (ev->state & Button4Mask) modifiers |= XEMACS_MOD_BUTTON4; | |
1303 if (ev->state & Button5Mask) modifiers |= XEMACS_MOD_BUTTON5; | |
428 | 1304 /* Currently ignores Shift_Lock but probably shouldn't |
1305 (but it definitely should ignore Caps_Lock). */ | |
1204 | 1306 SET_EVENT_MOTION_MODIFIERS (emacs_event, modifiers); |
428 | 1307 } |
1308 break; | |
1309 | |
1310 case ClientMessage: | |
1311 { | |
1312 /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is | |
1313 passed as the timestamp of the TAKE_FOCUS, which the ICCCM | |
1314 explicitly prohibits. */ | |
1315 XClientMessageEvent *ev = &x_event->xclient; | |
4790
bc4f2511bbea
Remove support for the OffiX drag-and-drop protocol. See xemacs-patches
Jerry James <james@xemacs.org>
parents:
4780
diff
changeset
|
1316 |
428 | 1317 if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d) |
1318 && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d) | |
1319 && (Atom) (ev->data.l[1]) == 0) | |
1320 { | |
1321 ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d); | |
1322 } | |
1323 } | |
1324 /* fall through */ | |
1325 | |
1326 default: /* it's a magic event */ | |
1327 { | |
1328 struct frame *frame; | |
1329 Window w; | |
934 | 1330 XEvent *x_event_copy; |
1331 SET_EVENT_TYPE (emacs_event, magic_event); | |
1204 | 1332 x_event_copy = &EVENT_MAGIC_X_EVENT (emacs_event); |
428 | 1333 |
1334 #define FROB(event_member, window_member) \ | |
1335 x_event_copy->event_member = x_event->event_member; \ | |
1336 w = x_event->event_member.window_member | |
1337 | |
1338 switch (x_event->type) | |
1339 { | |
1340 case SelectionRequest: FROB(xselectionrequest, owner); break; | |
1341 case SelectionClear: FROB(xselectionclear, window); break; | |
1342 case SelectionNotify: FROB(xselection, requestor); break; | |
1343 case PropertyNotify: FROB(xproperty, window); break; | |
1344 case ClientMessage: FROB(xclient, window); break; | |
1345 case ConfigureNotify: FROB(xconfigure, window); break; | |
1346 case Expose: | |
1347 case GraphicsExpose: FROB(xexpose, window); break; | |
1348 case MapNotify: | |
1349 case UnmapNotify: FROB(xmap, window); break; | |
1350 case EnterNotify: | |
1351 case LeaveNotify: FROB(xcrossing, window); break; | |
1352 case FocusIn: | |
1353 case FocusOut: FROB(xfocus, window); break; | |
1354 case VisibilityNotify: FROB(xvisibility, window); break; | |
442 | 1355 case CreateNotify: FROB(xcreatewindow, window); break; |
428 | 1356 default: |
1357 w = x_event->xany.window; | |
1358 *x_event_copy = *x_event; | |
1359 break; | |
1360 } | |
1361 #undef FROB | |
1362 frame = x_any_window_to_frame (d, w); | |
1363 | |
1364 if (!frame) | |
1365 return 0; | |
1366 | |
1204 | 1367 SET_EVENT_CHANNEL (emacs_event, wrap_frame (frame)); |
428 | 1368 break; |
1369 } | |
1370 } | |
1371 return 1; | |
1372 } | |
1373 | |
1374 | |
1375 | |
1376 /************************************************************************/ | |
1377 /* magic-event handling */ | |
1378 /************************************************************************/ | |
1379 | |
1380 static void | |
1381 handle_focus_event_1 (struct frame *f, int in_p) | |
1382 { | |
863 | 1383 handle_focus_event_2 (XtWindow (FRAME_X_TEXT_WIDGET (f)), f, in_p); |
1384 } | |
1385 | |
1386 static void | |
1387 handle_focus_event_2 (Window win, struct frame *f, int in_p) | |
1388 { | |
1389 /* Although this treats focus differently for all widgets (including | |
1390 the frame) it seems to work ok. */ | |
1391 Widget needs_it = XtWindowToWidget (FRAME_X_DISPLAY (f), win); | |
1392 | |
428 | 1393 #if XtSpecificationRelease > 5 |
450 | 1394 widget_with_focus = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f)); |
428 | 1395 #endif |
1396 #ifdef HAVE_XIM | |
1397 XIM_focus_event (f, in_p); | |
1398 #endif /* HAVE_XIM */ | |
450 | 1399 |
428 | 1400 /* On focus change, clear all memory of sticky modifiers |
1401 to avoid non-intuitive behavior. */ | |
1402 clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f))); | |
1403 | |
1404 /* We don't want to handle the focus change now, because we might | |
1405 be in an accept-process-output, sleep-for, or sit-for. So | |
1406 we enqueue it. | |
1407 | |
1408 Actually, we half handle it: we handle it as far as changing the | |
1409 box cursor for redisplay, but we don't call any hooks or do any | |
1410 select-frame stuff until after the sit-for. | |
1411 | |
1412 Unfortunately native widgets break the model because they grab | |
1413 the keyboard focus and nothing sets it back again. I cannot find | |
1414 any reasonable way to do this elsewhere so we assert here that | |
1415 the keyboard focus is on the emacs text widget. Menus and dialogs | |
1416 do this in their selection callback, but we don't want that since | |
1417 a button having focus is legitimate. An edit field having focus | |
1418 is mandatory. Weirdly you get a FocusOut event when you click in | |
442 | 1419 a widget-glyph but you don't get a corresponding FocusIn when you |
428 | 1420 click in the frame. Why is this? */ |
438 | 1421 if (in_p |
1422 #if XtSpecificationRelease > 5 | |
863 | 1423 && needs_it != widget_with_focus |
428 | 1424 #endif |
1425 ) | |
1426 { | |
863 | 1427 lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f), needs_it); |
428 | 1428 } |
450 | 1429 |
863 | 1430 /* If we are focusing on a native widget then record and exit. */ |
1431 if (needs_it != FRAME_X_TEXT_WIDGET (f)) { | |
1432 widget_with_focus = needs_it; | |
1433 return; | |
1434 } | |
1435 | |
450 | 1436 /* We have the focus now. See comment in |
1437 emacs_Xt_handle_widget_losing_focus (). */ | |
1438 if (in_p) | |
1439 widget_with_focus = NULL; | |
1440 | |
428 | 1441 /* do the generic event-stream stuff. */ |
1442 { | |
1443 Lisp_Object frm; | |
1444 Lisp_Object conser; | |
1445 struct gcpro gcpro1; | |
1446 | |
793 | 1447 frm = wrap_frame (f); |
428 | 1448 conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil)); |
1449 GCPRO1 (conser); | |
1450 emacs_handle_focus_change_preliminary (conser); | |
1451 enqueue_magic_eval_event (emacs_handle_focus_change_final, | |
1452 conser); | |
1453 UNGCPRO; | |
1454 } | |
1455 } | |
1456 | |
863 | 1457 /* Create a synthetic X focus event. */ |
1111 | 1458 void emacs_Xt_enqueue_focus_event (Widget wants_it, Lisp_Object frame, |
1459 int in_p); | |
863 | 1460 void |
1111 | 1461 emacs_Xt_enqueue_focus_event (Widget wants_it, Lisp_Object frame, int in_p) |
863 | 1462 { |
1463 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil); | |
1464 Lisp_Event *ev = XEVENT (emacs_event); | |
960 | 1465 XEvent *x_event; |
1466 | |
1467 XSET_EVENT_TYPE (emacs_event, magic_event); | |
1204 | 1468 x_event = &EVENT_MAGIC_X_EVENT (ev); |
863 | 1469 |
1470 x_event->type = in_p ? FocusIn : FocusOut; | |
1471 x_event->xfocus.window = XtWindow (wants_it); | |
1472 | |
960 | 1473 SET_EVENT_CHANNEL (ev, frame); |
1204 | 1474 |
1475 enqueue_dispatch_event (emacs_event); | |
863 | 1476 } |
1477 | |
450 | 1478 /* The idea here is that when a widget glyph gets unmapped we don't |
1479 want the focus to stay with it if it has focus - because it may | |
863 | 1480 well just get deleted next and then we have lost the focus until the |
450 | 1481 user does something. So handle_focus_event_1 records the widget |
1482 with keyboard focus when FocusOut is processed, and then, when a | |
1483 widget gets unmapped, it calls this function to restore focus if | |
1484 appropriate. */ | |
853 | 1485 void emacs_Xt_handle_widget_losing_focus (struct frame *f, Widget losing_widget); |
450 | 1486 void |
853 | 1487 emacs_Xt_handle_widget_losing_focus (struct frame *f, Widget losing_widget) |
450 | 1488 { |
1489 if (losing_widget == widget_with_focus) | |
1490 { | |
1491 handle_focus_event_1 (f, 1); | |
1492 } | |
1493 } | |
1494 | |
428 | 1495 /* This is called from the external-widget code */ |
1496 | |
1497 void emacs_Xt_handle_focus_event (XEvent *event); | |
1498 void | |
1499 emacs_Xt_handle_focus_event (XEvent *event) | |
1500 { | |
1501 struct device *d = get_device_from_display (event->xany.display); | |
1502 struct frame *f; | |
1503 | |
1504 if (DEVICE_X_BEING_DELETED (d)) | |
1505 return; | |
1506 | |
1507 /* | |
1508 * It's curious that we're using x_any_window_to_frame() instead | |
1509 * of x_window_to_frame(). I don't know what the impact of this is. | |
1510 */ | |
1511 f = x_any_window_to_frame (d, event->xfocus.window); | |
1512 if (!f) | |
1513 /* focus events are sometimes generated just before | |
1514 a frame is destroyed. */ | |
1515 return; | |
1516 handle_focus_event_1 (f, event->type == FocusIn); | |
1517 } | |
1518 | |
1519 /* both MapNotify and VisibilityNotify can cause this | |
1520 JV is_visible has the same semantics as f->visible*/ | |
1521 static void | |
1522 change_frame_visibility (struct frame *f, int is_visible) | |
1523 { | |
793 | 1524 Lisp_Object frame = wrap_frame (f); |
1525 | |
428 | 1526 |
1527 if (!FRAME_VISIBLE_P (f) && is_visible) | |
1528 { | |
1529 FRAME_VISIBLE_P (f) = is_visible; | |
872 | 1530 /* [[ This improves the double flicker when uniconifying a frame |
428 | 1531 some. A lot of it is not showing a buffer which has changed |
1532 while the frame was iconified. To fix it further requires | |
872 | 1533 the good 'ol double redisplay structure. ]] -- comment is |
1534 invalid, obviously predates 19.12, when the double redisplay | |
1535 structure (i.e. current + desired) was put back in. --ben */ | |
428 | 1536 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f); |
1537 va_run_hook_with_args (Qmap_frame_hook, 1, frame); | |
1538 } | |
1539 else if (FRAME_VISIBLE_P (f) && !is_visible) | |
1540 { | |
1541 FRAME_VISIBLE_P (f) = 0; | |
1542 va_run_hook_with_args (Qunmap_frame_hook, 1, frame); | |
1543 } | |
1544 else if (FRAME_VISIBLE_P (f) * is_visible < 0) | |
1545 { | |
1546 FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f); | |
1547 if (FRAME_REPAINT_P(f)) | |
1548 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f); | |
1549 va_run_hook_with_args (Qmap_frame_hook, 1, frame); | |
1550 } | |
1551 } | |
1552 | |
1553 static void | |
593 | 1554 update_frame_iconify_status (struct frame *f) |
1555 { | |
1556 f->iconified = (x_frame_window_state (f) == IconicState); | |
1557 } | |
1558 | |
1559 static void | |
428 | 1560 handle_map_event (struct frame *f, XEvent *event) |
1561 { | |
593 | 1562 |
1563 /* It seems that, given the multiplicity of window managers and X | |
1564 implementations, plus the fact that X was designed without | |
1565 window managers or icons in mind and this was then grafted on | |
1566 with about the skill of a drunk freshman med student attempting | |
1567 surgery with a rusty razor blade, we cannot treat any off | |
1568 MapNotify/UnmapNotify/VisibilityNotify as more than vague hints | |
1569 as to the actual situation. | |
1570 | |
1571 So we should just query the actual status. Unfortunately, things | |
1572 are worse because (a) there aren't obvious ways to query some | |
1573 of these values (e.g. "totally visible"), and (b) there may be | |
1574 race conditions (see below). | |
1575 | |
638 | 1576 However, according to the ICCCM, there's a specific way to |
593 | 1577 ask the window manager whether the state is (a) visible, |
1578 (b) iconic, (c) withdrawn. It must be one of these three. | |
1579 We already use this call to check for the iconified state. | |
1580 I'd suggest we do the same for visible (i.e. NormalState), | |
1581 and scrap most of the nasty code below. | |
1582 | |
1583 --ben | |
1584 */ | |
1585 | |
1586 update_frame_iconify_status (f); | |
1587 | |
1588 /* #### Ben suggests rewriting the code below using | |
1589 x_frame_window_state (f). */ | |
1590 | |
428 | 1591 if (event->type == MapNotify) |
1592 { | |
1593 XWindowAttributes xwa; | |
1594 | |
1595 /* Bleagh!!!!!! Apparently some window managers (e.g. MWM) | |
1596 send synthetic MapNotify events when a window is first | |
1597 created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE. | |
1598 Or something like that. We initially tried a different | |
1599 solution below, but that ran into a different window- | |
1600 manager bug. | |
1601 | |
1602 It seems that the only reliable way is to treat a | |
1603 MapNotify event as a "hint" that the window might or | |
1604 might not be visible, and check explicitly. */ | |
1605 | |
1606 XGetWindowAttributes (event->xany.display, event->xmap.window, | |
1607 &xwa); | |
1608 if (xwa.map_state != IsViewable) | |
593 | 1609 return; |
428 | 1610 |
1611 FRAME_X_TOTALLY_VISIBLE_P (f) = 1; | |
1612 #if 0 | |
1613 /* Bleagh again!!!! We initially tried the following hack | |
1614 around the MWM problem, but it turns out that TWM | |
1615 has a race condition when you un-iconify, where it maps | |
1616 the window and then tells the server that the window | |
1617 is un-iconified. Usually, XEmacs wakes up between | |
1618 those two occurrences, and thus thinks that un-iconified | |
1619 windows are still iconified. | |
1620 | |
1621 Ah, the joys of X. */ | |
1622 | |
1623 /* By Emacs definition, a frame that is iconified is not | |
1624 visible. Marking a frame as visible will automatically cause | |
1625 frame-iconified-p to return nil, regardless of whether the | |
1626 frame is actually iconified. Therefore, we have to ignore | |
1627 MapNotify events on iconified frames. (It's not obvious | |
1628 to me why these are being sent, but it happens at startup | |
1629 with frames that are initially iconified; perhaps they are | |
1630 synthetic MapNotify events coming from the window manager.) | |
1631 Note that `frame-iconified-p' queries the server | |
1632 to determine whether the frame is currently iconified, | |
1633 rather than consulting some internal (and likely | |
1634 inaccurate) state flag. Therefore, ignoring the MapNotify | |
1635 is correct. */ | |
793 | 1636 if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (wrap_frame (f)))) |
428 | 1637 #endif /* 0 */ |
1638 change_frame_visibility (f, 1); | |
1639 } | |
1640 else | |
1641 { | |
1642 FRAME_X_TOTALLY_VISIBLE_P (f) = 0; | |
1643 change_frame_visibility (f, 0); | |
1644 } | |
1645 } | |
1646 | |
1647 static void | |
1648 handle_client_message (struct frame *f, XEvent *event) | |
1649 { | |
1650 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
793 | 1651 Lisp_Object frame = wrap_frame (f); |
428 | 1652 |
1653 if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) && | |
1654 (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d)) | |
1655 { | |
1656 /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages, | |
1657 such as WM_TAKE_FOCUS, are eval events. That's because delete-window | |
1658 was probably executed with a mouse click, while the others could | |
1659 have been sent as a result of mouse motion or some other implicit | |
1660 action. (Call this a "heuristic"...) The reason for caring about | |
1661 this is so that clicking on the close-box will make emacs prompt | |
1662 using a dialog box instead of the minibuffer if there are unsaved | |
1663 buffers. | |
1664 */ | |
1665 enqueue_misc_user_event (frame, Qeval, | |
1666 list3 (Qdelete_frame, frame, Qt)); | |
1667 } | |
1668 else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) && | |
1669 (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d)) | |
1670 { | |
1671 handle_focus_event_1 (f, 1); | |
1672 #if 0 | |
1673 /* If there is a dialog box up, focus on it. | |
1674 | |
1675 #### Actually, we're raising it too, which is wrong. We should | |
1676 #### just focus on it, but lwlib doesn't currently give us an | |
1677 #### easy way to do that. This should be fixed. | |
1678 */ | |
1679 unsigned long take_focus_timestamp = event->xclient.data.l[1]; | |
1680 Widget widget = lw_raise_all_pop_up_widgets (); | |
1681 if (widget) | |
1682 { | |
1683 /* kludge: raise_all returns bottommost widget, but we really | |
1684 want the topmost. So just raise it for now. */ | |
1685 XMapRaised (XtDisplay (widget), XtWindow (widget)); | |
1686 /* Grab the focus with the timestamp of the TAKE_FOCUS. */ | |
1687 XSetInputFocus (XtDisplay (widget), XtWindow (widget), | |
1688 RevertToParent, take_focus_timestamp); | |
1689 } | |
1690 #endif | |
1691 } | |
1692 } | |
1693 | |
448 | 1694 /* #### I'm struggling to understand how the X event loop really works. |
1695 Here is the problem: | |
1696 | |
1697 When widgets get mapped / changed etc the actual display updates | |
1698 are done asynchronously via X events being processed - this | |
1699 normally happens when XtAppProcessEvent() gets called. However, if | |
1700 we are executing lisp code or even doing redisplay we won't | |
1701 necessarily process X events for a very long time. This has the | |
1702 effect of widgets only getting updated when XEmacs only goes into | |
1703 idle, or some other event causes processing of the X event queue. | |
1704 | |
1705 XtAppProcessEvent can get called from the following places: | |
1706 | |
1707 emacs_Xt_next_event () - this is normal event processing, almost | |
1708 any non-X event will take precedence and this means that we | |
1709 cannot rely on it to do the right thing at the right time for | |
1710 widget display. | |
1711 | |
1204 | 1712 emacs_Xt_drain_queue () - this happens when SIGIO gets tripped, |
1713 processing the event queue allows C-g to be checked for. It gets | |
1714 called from emacs_Xt_event_pending_p (). #### Update this comment. | |
448 | 1715 |
1716 In order to solve this I have tried introducing a list primitive - | |
1717 dispatch-non-command-events - which forces processing of X events | |
1718 related to display. Unfortunately this has a number of problems, | |
1719 one is that it is possible for event_stream_event_pending_p to | |
1720 block for ever if there isn't actually an event. I guess this can | |
1721 happen if we drop the synthetic event for reason. It also relies on | |
1722 SIGIO processing which makes things rather fragile. | |
1723 | |
1724 People have seen behaviour whereby XEmacs blocks until you move the | |
1725 mouse. This seems to indicate that dispatch-non-command-events is | |
1726 blocking. It may be that in a SIGIO world forcing SIGIO processing | |
1727 does the wrong thing. | |
1728 */ | |
428 | 1729 static void |
853 | 1730 emacs_Xt_force_event_pending (struct frame *f) |
442 | 1731 { |
1732 XEvent event; | |
1733 | |
853 | 1734 Display *dpy = DEVICE_X_DISPLAY (XDEVICE (FRAME_DEVICE (f))); |
442 | 1735 event.xclient.type = ClientMessage; |
1736 event.xclient.display = dpy; | |
1737 event.xclient.message_type = XInternAtom (dpy, "BumpQueue", False); | |
1738 event.xclient.format = 32; | |
1739 event.xclient.window = 0; | |
1740 | |
1741 /* Send the drop message */ | |
1742 XSendEvent(dpy, XtWindow (FRAME_X_SHELL_WIDGET (f)), | |
1743 True, NoEventMask, &event); | |
448 | 1744 /* We rely on SIGIO and friends to realise we have generated an |
1745 event. */ | |
442 | 1746 } |
1747 | |
1748 static void | |
788 | 1749 emacs_Xt_format_magic_event (Lisp_Event *event, Lisp_Object pstream) |
1750 { | |
1751 Lisp_Object console = CDFW_CONSOLE (EVENT_CHANNEL (event)); | |
1752 if (CONSOLE_X_P (XCONSOLE (console))) | |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
1753 write_ascstring |
1204 | 1754 (pstream, x_event_name ((EVENT_MAGIC_X_EVENT (event)).type)); |
788 | 1755 } |
1756 | |
1757 static int | |
1758 emacs_Xt_compare_magic_event (Lisp_Event *e1, Lisp_Event *e2) | |
1759 { | |
1760 if (CONSOLE_X_P (XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e1)))) && | |
1761 CONSOLE_X_P (XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e2))))) | |
1204 | 1762 return ((EVENT_MAGIC_X_EVENT (e1)).xany.serial == |
1763 (EVENT_MAGIC_X_EVENT (e2)).xany.serial); | |
788 | 1764 if (CONSOLE_X_P (XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e1)))) || |
1765 CONSOLE_X_P (XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e2))))) | |
1766 return 0; | |
1767 return 1; | |
1768 } | |
1769 | |
1770 static Hashcode | |
1771 emacs_Xt_hash_magic_event (Lisp_Event *e) | |
1772 { | |
1773 Lisp_Object console = CDFW_CONSOLE (EVENT_CHANNEL (e)); | |
1774 if (CONSOLE_X_P (XCONSOLE (console))) | |
1204 | 1775 return (EVENT_MAGIC_X_EVENT (e)).xany.serial; |
788 | 1776 return 0; |
1777 } | |
1778 | |
1779 static void | |
440 | 1780 emacs_Xt_handle_magic_event (Lisp_Event *emacs_event) |
428 | 1781 { |
1782 /* This function can GC */ | |
1204 | 1783 XEvent *event = &EVENT_MAGIC_X_EVENT (emacs_event); |
428 | 1784 struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event)); |
1785 | |
1786 if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f)))) | |
1787 return; | |
1788 | |
1789 switch (event->type) | |
1790 { | |
1791 case SelectionRequest: | |
1792 x_handle_selection_request (&event->xselectionrequest); | |
1793 break; | |
934 | 1794 |
428 | 1795 case SelectionClear: |
1796 x_handle_selection_clear (&event->xselectionclear); | |
1797 break; | |
934 | 1798 |
428 | 1799 case SelectionNotify: |
1800 x_handle_selection_notify (&event->xselection); | |
1801 break; | |
934 | 1802 |
428 | 1803 case PropertyNotify: |
1804 x_handle_property_notify (&event->xproperty); | |
1805 break; | |
934 | 1806 |
428 | 1807 case Expose: |
1808 if (!check_for_ignored_expose (f, event->xexpose.x, event->xexpose.y, | |
1318 | 1809 event->xexpose.width, |
1810 event->xexpose.height) | |
428 | 1811 && |
1812 !find_matching_subwindow (f, event->xexpose.x, event->xexpose.y, | |
1813 event->xexpose.width, event->xexpose.height)) | |
1318 | 1814 redisplay_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y, |
1815 event->xexpose.width, | |
1816 event->xexpose.height); | |
428 | 1817 break; |
1818 | |
1819 case GraphicsExpose: /* This occurs when an XCopyArea's source area was | |
1820 obscured or not available. */ | |
1318 | 1821 redisplay_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y, |
1822 event->xexpose.width, | |
1823 event->xexpose.height); | |
428 | 1824 break; |
1825 | |
1826 case MapNotify: | |
1827 case UnmapNotify: | |
1828 handle_map_event (f, event); | |
1829 break; | |
1830 | |
1831 case EnterNotify: | |
1832 if (event->xcrossing.detail != NotifyInferior) | |
1833 { | |
793 | 1834 Lisp_Object frame = wrap_frame (f); |
1835 | |
428 | 1836 /* FRAME_X_MOUSE_P (f) = 1; */ |
1837 va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame); | |
1838 } | |
1839 break; | |
1840 | |
1841 case LeaveNotify: | |
1842 if (event->xcrossing.detail != NotifyInferior) | |
1843 { | |
793 | 1844 Lisp_Object frame = wrap_frame (f); |
1845 | |
428 | 1846 /* FRAME_X_MOUSE_P (f) = 0; */ |
1847 va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame); | |
1848 } | |
1849 break; | |
1850 | |
1851 case FocusIn: | |
1852 case FocusOut: | |
1853 | |
1854 #ifdef EXTERNAL_WIDGET | |
1855 /* External widget lossage: Ben said: | |
1856 YUCK. The only way to make focus changes work properly is to | |
1857 completely ignore all FocusIn/FocusOut events and depend only | |
1858 on notifications from the ExternalClient widget. */ | |
1859 if (FRAME_X_EXTERNAL_WINDOW_P (f)) | |
1860 break; | |
1861 #endif | |
863 | 1862 handle_focus_event_2 (event->xfocus.window, f, event->type == FocusIn); |
428 | 1863 break; |
1864 | |
1865 case ClientMessage: | |
1866 handle_client_message (f, event); | |
1867 break; | |
1868 | |
1869 case VisibilityNotify: /* window visibility has changed */ | |
1870 if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f))) | |
1871 { | |
593 | 1872 /* See comment in handle_map_event */ |
1873 update_frame_iconify_status (f); | |
1874 | |
1875 /* #### Ben suggests rewriting the code below using | |
1876 x_frame_window_state (f). */ | |
428 | 1877 FRAME_X_TOTALLY_VISIBLE_P (f) = |
1878 (event->xvisibility.state == VisibilityUnobscured); | |
1879 /* Note that the fvwm pager only sends VisibilityNotify when | |
1880 changing pages. Is this all we need to do ? JV */ | |
1881 /* Nope. We must at least trigger a redisplay here. | |
1882 Since this case seems similar to MapNotify, I've | |
1883 factored out some code to change_frame_visibility(). | |
1884 This triggers the necessary redisplay and runs | |
1885 (un)map-frame-hook. - dkindred@cs.cmu.edu */ | |
1886 /* Changed it again to support the tristate visibility flag */ | |
1887 change_frame_visibility (f, (event->xvisibility.state | |
1888 != VisibilityFullyObscured) ? 1 : -1); | |
1889 } | |
1890 break; | |
1891 | |
1892 case ConfigureNotify: | |
1893 #ifdef HAVE_XIM | |
1894 XIM_SetGeometry (f); | |
1895 #endif | |
1896 break; | |
1897 | |
442 | 1898 case CreateNotify: |
1899 break; | |
1900 | |
428 | 1901 default: |
1902 break; | |
1903 } | |
1904 } | |
1905 | |
1906 | |
1907 /************************************************************************/ | |
1908 /* timeout events */ | |
1909 /************************************************************************/ | |
1910 | |
1911 static int timeout_id_tick; | |
1912 | |
1913 /* Xt interval id's might not fit into an int (they're pointers, as it | |
1914 happens), so we need to provide a conversion list. */ | |
1915 | |
1916 static struct Xt_timeout | |
1917 { | |
1918 int id; | |
1919 XtIntervalId interval_id; | |
1920 struct Xt_timeout *next; | |
1921 } *pending_timeouts, *completed_timeouts; | |
1922 | |
1923 static struct Xt_timeout_blocktype | |
1924 { | |
1925 Blocktype_declare (struct Xt_timeout); | |
1926 } *the_Xt_timeout_blocktype; | |
1927 | |
1928 /* called by XtAppNextEvent() */ | |
1929 static void | |
2286 | 1930 Xt_timeout_callback (XtPointer closure, XtIntervalId *UNUSED (id)) |
428 | 1931 { |
1932 struct Xt_timeout *timeout = (struct Xt_timeout *) closure; | |
1933 struct Xt_timeout *t2 = pending_timeouts; | |
1934 /* Remove this one from the list of pending timeouts */ | |
1935 if (t2 == timeout) | |
1936 pending_timeouts = pending_timeouts->next; | |
1937 else | |
1938 { | |
1939 while (t2->next && t2->next != timeout) t2 = t2->next; | |
1940 assert (t2->next); | |
1941 t2->next = t2->next->next; | |
1942 } | |
1943 /* Add this one to the list of completed timeouts */ | |
1944 timeout->next = completed_timeouts; | |
1945 completed_timeouts = timeout; | |
1946 } | |
1947 | |
1948 static int | |
1949 emacs_Xt_add_timeout (EMACS_TIME thyme) | |
1950 { | |
1951 struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype); | |
1952 EMACS_TIME current_time; | |
1953 int milliseconds; | |
1954 | |
1955 timeout->id = timeout_id_tick++; | |
1956 timeout->next = pending_timeouts; | |
1957 pending_timeouts = timeout; | |
1958 EMACS_GET_TIME (current_time); | |
1959 EMACS_SUB_TIME (thyme, thyme, current_time); | |
1960 milliseconds = EMACS_SECS (thyme) * 1000 + | |
1961 EMACS_USECS (thyme) / 1000; | |
1962 if (milliseconds < 1) | |
1963 milliseconds = 1; | |
1964 timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds, | |
1965 Xt_timeout_callback, | |
1966 (XtPointer) timeout); | |
1967 return timeout->id; | |
1968 } | |
1969 | |
1970 static void | |
1971 emacs_Xt_remove_timeout (int id) | |
1972 { | |
1973 struct Xt_timeout *timeout, *t2; | |
1974 | |
1975 timeout = NULL; | |
1976 | |
1977 /* Find the timeout on the list of pending ones, if it's still there. */ | |
1978 if (pending_timeouts) | |
1979 { | |
1980 if (id == pending_timeouts->id) | |
1981 { | |
1982 timeout = pending_timeouts; | |
1983 pending_timeouts = pending_timeouts->next; | |
1984 } | |
1985 else | |
1986 { | |
1987 t2 = pending_timeouts; | |
1988 while (t2->next && t2->next->id != id) t2 = t2->next; | |
1989 if ( t2->next) /*found it */ | |
1990 { | |
1991 timeout = t2->next; | |
1992 t2->next = t2->next->next; | |
1993 } | |
1994 } | |
1995 /* if it was pending, we have removed it from the list */ | |
1996 if (timeout) | |
1997 XtRemoveTimeOut (timeout->interval_id); | |
1998 } | |
1999 | |
2000 /* It could be that the Xt call back was already called but we didn't convert | |
2001 into an Emacs event yet */ | |
2002 if (!timeout && completed_timeouts) | |
2003 { | |
2004 /* Code duplication! */ | |
2005 if (id == completed_timeouts->id) | |
2006 { | |
2007 timeout = completed_timeouts; | |
2008 completed_timeouts = completed_timeouts->next; | |
2009 } | |
2010 else | |
2011 { | |
2012 t2 = completed_timeouts; | |
2013 while (t2->next && t2->next->id != id) t2 = t2->next; | |
2014 if ( t2->next) /*found it */ | |
2015 { | |
2016 timeout = t2->next; | |
2017 t2->next = t2->next->next; | |
2018 } | |
2019 } | |
2020 } | |
2021 | |
2022 /* If we found the thing on the lists of timeouts, | |
2023 and removed it, deallocate | |
2024 */ | |
2025 if (timeout) | |
2026 Blocktype_free (the_Xt_timeout_blocktype, timeout); | |
2027 } | |
2028 | |
2029 static void | |
440 | 2030 Xt_timeout_to_emacs_event (Lisp_Event *emacs_event) |
428 | 2031 { |
2032 struct Xt_timeout *timeout = completed_timeouts; | |
2033 assert (timeout); | |
2034 completed_timeouts = completed_timeouts->next; | |
934 | 2035 /* timeout events have nil as channel */ |
1204 | 2036 set_event_type (emacs_event, timeout_event); |
934 | 2037 SET_EVENT_TIMESTAMP_ZERO (emacs_event); /* #### wrong!! */ |
1204 | 2038 SET_EVENT_TIMEOUT_INTERVAL_ID (emacs_event, timeout->id); |
2039 SET_EVENT_TIMEOUT_FUNCTION (emacs_event, Qnil); | |
2040 SET_EVENT_TIMEOUT_OBJECT (emacs_event, Qnil); | |
428 | 2041 Blocktype_free (the_Xt_timeout_blocktype, timeout); |
2042 } | |
2043 | |
2044 | |
2045 /************************************************************************/ | |
2046 /* process and tty events */ | |
2047 /************************************************************************/ | |
2048 | |
2049 struct what_is_ready_closure | |
2050 { | |
2051 int fd; | |
2052 Lisp_Object what; | |
2053 XtInputId id; | |
2054 }; | |
2055 | |
2056 static Lisp_Object *filedesc_with_input; | |
2057 static struct what_is_ready_closure **filedesc_to_what_closure; | |
2058 | |
2059 static void | |
2060 init_what_input_once (void) | |
2061 { | |
2062 int i; | |
2063 | |
2064 filedesc_with_input = xnew_array (Lisp_Object, MAXDESC); | |
2065 filedesc_to_what_closure = | |
2066 xnew_array (struct what_is_ready_closure *, MAXDESC); | |
2067 | |
2068 for (i = 0; i < MAXDESC; i++) | |
2069 { | |
2070 filedesc_to_what_closure[i] = 0; | |
2071 filedesc_with_input[i] = Qnil; | |
2072 } | |
2073 | |
2074 process_events_occurred = 0; | |
2075 tty_events_occurred = 0; | |
2076 } | |
2077 | |
2078 static void | |
2079 mark_what_as_being_ready (struct what_is_ready_closure *closure) | |
2080 { | |
2081 if (NILP (filedesc_with_input[closure->fd])) | |
2082 { | |
2083 SELECT_TYPE temp_mask; | |
2084 FD_ZERO (&temp_mask); | |
2085 FD_SET (closure->fd, &temp_mask); | |
2086 /* Check to make sure there's *really* input available. | |
2087 Sometimes things seem to get confused and this gets called | |
2088 for the tty fd when there's really only input available | |
2089 on some process's fd. (It will subsequently get called | |
2090 for that process's fd, so returning without setting any | |
2091 flags will take care of it.) To see the problem, uncomment | |
2092 the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS | |
2093 down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log' | |
2094 and press return repeatedly. (Seen under AIX & Linux.) | |
2095 -dkindred@cs.cmu.edu */ | |
2096 if (!poll_fds_for_input (temp_mask)) | |
2097 { | |
2098 #if 0 | |
2099 stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n", | |
2100 closure->fd); | |
2101 #endif | |
2102 return; | |
2103 } | |
2104 filedesc_with_input[closure->fd] = closure->what; | |
2105 if (PROCESSP (closure->what)) | |
2106 /* Don't increment this if the current process is already marked | |
2107 * as having input. */ | |
2108 process_events_occurred++; | |
2109 else | |
2110 tty_events_occurred++; | |
2111 } | |
2112 } | |
2113 | |
2114 static void | |
2286 | 2115 Xt_what_callback (void *closure, int *UNUSED (source), XtInputId *UNUSED (id)) |
428 | 2116 { |
2117 /* If closure is 0, then we got a fake event from a signal handler. | |
2118 The only purpose of this is to make XtAppProcessEvent() stop | |
2119 blocking. */ | |
2120 if (closure) | |
2121 mark_what_as_being_ready ((struct what_is_ready_closure *) closure); | |
2122 else | |
2123 { | |
2124 fake_event_occurred++; | |
2125 drain_signal_event_pipe (); | |
2126 } | |
2127 } | |
2128 | |
2129 static void | |
2130 select_filedesc (int fd, Lisp_Object what) | |
2131 { | |
2132 struct what_is_ready_closure *closure; | |
2133 | |
2134 /* If somebody is trying to select something that's already selected | |
2135 for, then something went wrong. The generic routines ought to | |
2136 detect this and error before here. */ | |
2137 assert (!filedesc_to_what_closure[fd]); | |
2138 | |
2139 closure = xnew (struct what_is_ready_closure); | |
2140 closure->fd = fd; | |
2141 closure->what = what; | |
2142 closure->id = | |
2143 XtAppAddInput (Xt_app_con, fd, | |
2144 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */), | |
2145 Xt_what_callback, closure); | |
2146 filedesc_to_what_closure[fd] = closure; | |
2147 } | |
2148 | |
2149 static void | |
2150 unselect_filedesc (int fd) | |
2151 { | |
2152 struct what_is_ready_closure *closure = filedesc_to_what_closure[fd]; | |
2153 | |
2154 assert (closure); | |
2155 if (!NILP (filedesc_with_input[fd])) | |
2156 { | |
2157 /* We are unselecting this process before we have drained the rest of | |
2158 the input from it, probably from status_notify() in the command loop. | |
2159 This can happen like so: | |
2160 | |
2161 - We are waiting in XtAppNextEvent() | |
2162 - Process generates output | |
2163 - Process is marked as being ready | |
2164 - Process dies, SIGCHLD gets generated before we return (!?) | |
2165 It could happen I guess. | |
2166 - sigchld_handler() marks process as dead | |
2167 - Somehow we end up getting a new KeyPress event on the queue | |
2168 at the same time (I'm really so sure how that happens but I'm | |
2169 not sure it can't either so let's assume it can...). | |
2170 - Key events have priority so we return that instead of the proc. | |
2171 - Before dispatching the lisp key event we call status_notify() | |
2172 - Which deselects the process that SIGCHLD marked as dead. | |
2173 | |
2174 Thus we never remove it from _with_input and turn it into a lisp | |
2175 event, so we need to do it here. But this does not mean that we're | |
2176 throwing away the last block of output - status_notify() has already | |
2177 taken care of running the proc filter or whatever. | |
2178 */ | |
2179 filedesc_with_input[fd] = Qnil; | |
2180 if (PROCESSP (closure->what)) | |
2181 { | |
2182 assert (process_events_occurred > 0); | |
2183 process_events_occurred--; | |
2184 } | |
2185 else | |
2186 { | |
2187 assert (tty_events_occurred > 0); | |
2188 tty_events_occurred--; | |
2189 } | |
2190 } | |
2191 XtRemoveInput (closure->id); | |
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
2192 xfree (closure); |
428 | 2193 filedesc_to_what_closure[fd] = 0; |
2194 } | |
2195 | |
2196 static void | |
853 | 2197 emacs_Xt_select_process (Lisp_Process *process, int doin, int doerr) |
428 | 2198 { |
853 | 2199 Lisp_Object proc; |
2200 int infd, errfd; | |
2201 | |
2202 event_stream_unixoid_select_process (process, doin, doerr, &infd, &errfd); | |
2203 | |
2204 proc = wrap_process (process); | |
2205 if (doin) | |
2206 select_filedesc (infd, proc); | |
2207 if (doerr) | |
2208 select_filedesc (errfd, proc); | |
2209 } | |
2210 | |
2211 static void | |
2212 emacs_Xt_unselect_process (Lisp_Process *process, int doin, int doerr) | |
2213 { | |
2214 int infd, errfd; | |
2215 | |
2216 event_stream_unixoid_unselect_process (process, doin, doerr, &infd, &errfd); | |
2217 | |
2218 if (doin) | |
2219 unselect_filedesc (infd); | |
2220 if (doerr) | |
2221 unselect_filedesc (errfd); | |
428 | 2222 } |
2223 | |
2224 static void | |
853 | 2225 emacs_Xt_create_io_streams (void *inhandle, void *outhandle, |
2226 void *errhandle, Lisp_Object *instream, | |
2227 Lisp_Object *outstream, | |
2228 Lisp_Object *errstream, | |
2229 USID *in_usid, | |
2230 USID *err_usid, | |
2231 int flags) | |
428 | 2232 { |
853 | 2233 event_stream_unixoid_create_io_streams |
2234 (inhandle, outhandle, errhandle, instream, outstream, | |
2235 errstream, in_usid, err_usid, flags); | |
2236 if (*in_usid != USID_ERROR) | |
2237 *in_usid = USID_DONTHASH; | |
2238 if (*err_usid != USID_ERROR) | |
2239 *err_usid = USID_DONTHASH; | |
428 | 2240 } |
2241 | |
853 | 2242 static void |
2243 emacs_Xt_delete_io_streams (Lisp_Object instream, | |
2244 Lisp_Object outstream, | |
2245 Lisp_Object errstream, | |
2246 USID *in_usid, | |
2247 USID *err_usid) | |
428 | 2248 { |
853 | 2249 event_stream_unixoid_delete_io_streams |
2250 (instream, outstream, errstream, in_usid, err_usid); | |
2251 *in_usid = USID_DONTHASH; | |
2252 *err_usid = USID_DONTHASH; | |
428 | 2253 } |
2254 | |
2255 /* This is called from GC when a process object is about to be freed. | |
2256 If we've still got pointers to it in this file, we're gonna lose hard. | |
2257 */ | |
2258 void | |
2286 | 2259 debug_process_finalization (Lisp_Process *UNUSED (p)) |
428 | 2260 { |
2261 #if 0 /* #### */ | |
2262 int i; | |
853 | 2263 Lisp_Object instr, outstr, errstr; |
2264 | |
2265 get_process_streams (p, &instr, &outstr, &errstr); | |
428 | 2266 /* if it still has fds, then it hasn't been killed yet. */ |
2267 assert (NILP(instr)); | |
2268 assert (NILP(outstr)); | |
853 | 2269 assert (NILP(errstr)); |
428 | 2270 /* Better not still be in the "with input" table; we know it's got no fds. */ |
2271 for (i = 0; i < MAXDESC; i++) | |
2272 { | |
2273 Lisp_Object process = filedesc_fds_with_input [i]; | |
2274 assert (!PROCESSP (process) || XPROCESS (process) != p); | |
2275 } | |
2276 #endif | |
2277 } | |
2278 | |
2279 static void | |
440 | 2280 Xt_process_to_emacs_event (Lisp_Event *emacs_event) |
428 | 2281 { |
2282 int i; | |
2283 | |
2284 assert (process_events_occurred > 0); | |
438 | 2285 |
428 | 2286 for (i = 0; i < MAXDESC; i++) |
2287 { | |
438 | 2288 Lisp_Object process = filedesc_with_input[i]; |
428 | 2289 if (PROCESSP (process)) |
438 | 2290 { |
2291 filedesc_with_input[i] = Qnil; | |
2292 process_events_occurred--; | |
2293 /* process events have nil as channel */ | |
934 | 2294 set_event_type (emacs_event, process_event); |
2295 SET_EVENT_TIMESTAMP_ZERO (emacs_event); /* #### */ | |
1204 | 2296 SET_EVENT_PROCESS_PROCESS (emacs_event, process); |
438 | 2297 return; |
2298 } | |
428 | 2299 } |
2500 | 2300 ABORT (); |
428 | 2301 } |
2302 | |
2303 static void | |
2304 emacs_Xt_select_console (struct console *con) | |
2305 { | |
2306 Lisp_Object console; | |
2307 int infd; | |
2308 | |
2309 if (CONSOLE_X_P (con)) | |
2310 return; /* X consoles are automatically selected for when we | |
2311 initialize them in Xt */ | |
2312 infd = event_stream_unixoid_select_console (con); | |
793 | 2313 console = wrap_console (con); |
428 | 2314 select_filedesc (infd, console); |
2315 } | |
2316 | |
2317 static void | |
2318 emacs_Xt_unselect_console (struct console *con) | |
2319 { | |
2320 int infd; | |
2321 | |
2322 if (CONSOLE_X_P (con)) | |
2323 return; /* X consoles are automatically selected for when we | |
2324 initialize them in Xt */ | |
2325 infd = event_stream_unixoid_unselect_console (con); | |
2326 unselect_filedesc (infd); | |
2327 } | |
2328 | |
2329 /* read an event from a tty, if one is available. Returns non-zero | |
2330 if an event was available. Note that when this function is | |
2331 called, there should always be a tty marked as ready for input. | |
2332 However, the input condition might actually be EOF, so there | |
2333 may not really be any input available. (In this case, | |
2334 read_event_from_tty_or_stream_desc() will arrange for the TTY device | |
2335 to be deleted.) */ | |
2336 | |
2337 static int | |
440 | 2338 Xt_tty_to_emacs_event (Lisp_Event *emacs_event) |
428 | 2339 { |
2340 int i; | |
2341 | |
2342 assert (tty_events_occurred > 0); | |
2343 for (i = 0; i < MAXDESC; i++) | |
2344 { | |
2345 Lisp_Object console = filedesc_with_input[i]; | |
2346 if (CONSOLEP (console)) | |
2347 { | |
2348 assert (tty_events_occurred > 0); | |
2349 tty_events_occurred--; | |
2350 filedesc_with_input[i] = Qnil; | |
771 | 2351 if (read_event_from_tty_or_stream_desc (emacs_event, |
2352 XCONSOLE (console))) | |
428 | 2353 return 1; |
2354 } | |
2355 } | |
2356 | |
2357 return 0; | |
2358 } | |
2359 | |
2360 | |
2361 /************************************************************************/ | |
2362 /* debugging functions to decipher an event */ | |
2363 /************************************************************************/ | |
2364 | |
2365 #ifdef DEBUG_XEMACS | |
2366 #include "xintrinsicp.h" /* only describe_event() needs this */ | |
2367 #include <X11/Xproto.h> /* only describe_event() needs this */ | |
2368 | |
2369 static void | |
788 | 2370 describe_event_window (Window window, Display *display, Lisp_Object pstream) |
428 | 2371 { |
2372 struct frame *f; | |
2373 Widget w; | |
788 | 2374 write_fmt_string (pstream, " window: 0x%lx", (unsigned long) window); |
428 | 2375 w = XtWindowToWidget (display, window); |
2376 if (w) | |
788 | 2377 write_fmt_string (pstream, " %s", |
2378 w->core.widget_class->core_class.class_name); | |
428 | 2379 f = x_any_window_to_frame (get_device_from_display (display), window); |
2380 if (f) | |
788 | 2381 write_fmt_string_lisp (pstream, " \"%s\"", 1, f->name); |
2382 write_fmt_string (pstream, "\n"); | |
428 | 2383 } |
2384 | |
442 | 2385 static const char * |
428 | 2386 XEvent_mode_to_string (int mode) |
2387 { | |
2388 switch (mode) | |
2389 { | |
2390 case NotifyNormal: return "Normal"; | |
2391 case NotifyGrab: return "Grab"; | |
2392 case NotifyUngrab: return "Ungrab"; | |
2393 case NotifyWhileGrabbed: return "WhileGrabbed"; | |
2394 default: return "???"; | |
2395 } | |
2396 } | |
2397 | |
442 | 2398 static const char * |
428 | 2399 XEvent_detail_to_string (int detail) |
2400 { | |
2401 switch (detail) | |
2402 { | |
2403 case NotifyAncestor: return "Ancestor"; | |
2404 case NotifyInferior: return "Inferior"; | |
2405 case NotifyNonlinear: return "Nonlinear"; | |
2406 case NotifyNonlinearVirtual: return "NonlinearVirtual"; | |
2407 case NotifyPointer: return "Pointer"; | |
2408 case NotifyPointerRoot: return "PointerRoot"; | |
2409 case NotifyDetailNone: return "DetailNone"; | |
2410 default: return "???"; | |
2411 } | |
2412 } | |
2413 | |
442 | 2414 static const char * |
428 | 2415 XEvent_visibility_to_string (int state) |
2416 { | |
2417 switch (state) | |
2418 { | |
2419 case VisibilityFullyObscured: return "FullyObscured"; | |
2420 case VisibilityPartiallyObscured: return "PartiallyObscured"; | |
2421 case VisibilityUnobscured: return "Unobscured"; | |
2422 default: return "???"; | |
2423 } | |
2424 } | |
2425 | |
2426 static void | |
788 | 2427 describe_event (XEvent *event, Lisp_Object pstream) |
428 | 2428 { |
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
2429 Ascbyte buf[100]; |
428 | 2430 struct device *d = get_device_from_display (event->xany.display); |
2431 | |
2432 sprintf (buf, "%s%s", x_event_name (event->type), | |
2433 event->xany.send_event ? " (send)" : ""); | |
788 | 2434 write_fmt_string (pstream, "%-30s", buf); |
428 | 2435 switch (event->type) |
2436 { | |
2437 case FocusIn: | |
2438 case FocusOut: | |
2439 { | |
2440 XFocusChangeEvent *ev = &event->xfocus; | |
788 | 2441 describe_event_window (ev->window, ev->display, pstream); |
2442 write_fmt_string (pstream, " mode: %s\n", | |
2443 XEvent_mode_to_string (ev->mode)); | |
2444 write_fmt_string (pstream, " detail: %s\n", | |
2445 XEvent_detail_to_string (ev->detail)); | |
428 | 2446 break; |
2447 } | |
2448 | |
2449 case KeyPress: | |
2450 { | |
2451 XKeyEvent *ev = &event->xkey; | |
2452 unsigned int state = ev->state; | |
2453 | |
788 | 2454 describe_event_window (ev->window, ev->display, pstream); |
2455 write_fmt_string (pstream, " subwindow: %ld\n", ev->subwindow); | |
2456 write_fmt_string (pstream, " state: "); | |
428 | 2457 /* Complete list of modifier key masks */ |
788 | 2458 if (state & ShiftMask) write_fmt_string (pstream, "Shift "); |
2459 if (state & LockMask) write_fmt_string (pstream, "Lock "); | |
2460 if (state & ControlMask) write_fmt_string (pstream, "Control "); | |
2461 if (state & Mod1Mask) write_fmt_string (pstream, "Mod1 "); | |
2462 if (state & Mod2Mask) write_fmt_string (pstream, "Mod2 "); | |
2463 if (state & Mod3Mask) write_fmt_string (pstream, "Mod3 "); | |
2464 if (state & Mod4Mask) write_fmt_string (pstream, "Mod4 "); | |
2465 if (state & Mod5Mask) write_fmt_string (pstream, "Mod5 "); | |
428 | 2466 |
2467 if (! state) | |
788 | 2468 write_fmt_string (pstream, "vanilla\n"); |
428 | 2469 else |
788 | 2470 write_fmt_string (pstream, "\n"); |
428 | 2471 if (x_key_is_modifier_p (ev->keycode, d)) |
788 | 2472 write_fmt_string (pstream, " Modifier key"); |
2473 write_fmt_string (pstream, " keycode: 0x%x\n", ev->keycode); | |
428 | 2474 } |
2475 break; | |
2476 | |
2477 case Expose: | |
442 | 2478 if (debug_x_events > 1) |
428 | 2479 { |
2480 XExposeEvent *ev = &event->xexpose; | |
788 | 2481 describe_event_window (ev->window, ev->display, pstream); |
2482 write_fmt_string (pstream, | |
2483 " region: x=%d y=%d width=%d height=%d\n", | |
428 | 2484 ev->x, ev->y, ev->width, ev->height); |
788 | 2485 write_fmt_string (pstream, " count: %d\n", ev->count); |
428 | 2486 } |
2487 else | |
788 | 2488 write_fmt_string (pstream, "\n"); |
428 | 2489 break; |
2490 | |
2491 case GraphicsExpose: | |
442 | 2492 if (debug_x_events > 1) |
428 | 2493 { |
2494 XGraphicsExposeEvent *ev = &event->xgraphicsexpose; | |
788 | 2495 describe_event_window (ev->drawable, ev->display, pstream); |
2496 write_fmt_string (pstream, " major: %s\n", | |
428 | 2497 (ev ->major_code == X_CopyArea ? "CopyArea" : |
2498 (ev->major_code == X_CopyPlane ? "CopyPlane" : "?"))); | |
788 | 2499 write_fmt_string (pstream, |
2500 " region: x=%d y=%d width=%d height=%d\n", | |
428 | 2501 ev->x, ev->y, ev->width, ev->height); |
788 | 2502 write_fmt_string (pstream, " count: %d\n", ev->count); |
428 | 2503 } |
2504 else | |
788 | 2505 write_fmt_string (pstream, "\n"); |
428 | 2506 break; |
2507 | |
2508 case EnterNotify: | |
2509 case LeaveNotify: | |
442 | 2510 if (debug_x_events > 1) |
428 | 2511 { |
2512 XCrossingEvent *ev = &event->xcrossing; | |
788 | 2513 describe_event_window (ev->window, ev->display, pstream); |
428 | 2514 #if 0 |
788 | 2515 write_fmt_string (pstream, " subwindow: 0x%x\n", ev->subwindow); |
2516 write_fmt_string (pstream, " pos: %d %d\n", ev->x, ev->y); | |
2517 write_fmt_string (pstream, " root pos: %d %d\n", ev->x_root, | |
2518 ev->y_root); | |
428 | 2519 #endif |
788 | 2520 write_fmt_string (pstream, " mode: %s\n", |
2521 XEvent_mode_to_string(ev->mode)); | |
2522 write_fmt_string (pstream, " detail: %s\n", | |
2523 XEvent_detail_to_string(ev->detail)); | |
2524 write_fmt_string (pstream, " focus: %d\n", ev->focus); | |
428 | 2525 #if 0 |
788 | 2526 write_fmt_string (pstream, " state: 0x%x\n", ev->state); |
428 | 2527 #endif |
2528 } | |
2529 else | |
788 | 2530 write_fmt_string (pstream, "\n"); |
428 | 2531 break; |
2532 | |
2533 case ConfigureNotify: | |
442 | 2534 if (debug_x_events > 1) |
428 | 2535 { |
2536 XConfigureEvent *ev = &event->xconfigure; | |
788 | 2537 describe_event_window (ev->window, ev->display, pstream); |
2538 write_fmt_string (pstream, " above: 0x%lx\n", ev->above); | |
2539 write_fmt_string (pstream, " size: %d %d %d %d\n", ev->x, ev->y, | |
428 | 2540 ev->width, ev->height); |
788 | 2541 write_fmt_string (pstream, " redirect: %d\n", |
2542 ev->override_redirect); | |
428 | 2543 } |
2544 else | |
788 | 2545 write_fmt_string (pstream, "\n"); |
428 | 2546 break; |
2547 | |
2548 case VisibilityNotify: | |
442 | 2549 if (debug_x_events > 1) |
428 | 2550 { |
2551 XVisibilityEvent *ev = &event->xvisibility; | |
788 | 2552 describe_event_window (ev->window, ev->display, pstream); |
2553 write_fmt_string (pstream, " state: %s\n", | |
2554 XEvent_visibility_to_string (ev->state)); | |
428 | 2555 } |
2556 else | |
788 | 2557 write_fmt_string (pstream, "\n"); |
428 | 2558 break; |
2559 | |
2560 case ClientMessage: | |
2561 { | |
2562 XClientMessageEvent *ev = &event->xclient; | |
2563 char *name = XGetAtomName (ev->display, ev->message_type); | |
788 | 2564 write_fmt_string (pstream, "%s", name); |
2565 if (!strcmp (name, "WM_PROTOCOLS")) | |
2566 { | |
2567 char *protname = XGetAtomName (ev->display, ev->data.l[0]); | |
2568 write_fmt_string (pstream, "(%s)", protname); | |
2569 XFree (protname); | |
2570 } | |
428 | 2571 XFree (name); |
788 | 2572 write_fmt_string (pstream, "\n"); |
428 | 2573 break; |
2574 } | |
2575 | |
2576 default: | |
788 | 2577 write_fmt_string (pstream, "\n"); |
428 | 2578 break; |
2579 } | |
2580 | |
2581 fflush (stdout); | |
2582 } | |
2583 | |
2584 #endif /* include describe_event definition */ | |
2585 | |
2586 | |
2587 /************************************************************************/ | |
2588 /* get the next event from Xt */ | |
2589 /************************************************************************/ | |
2590 | |
2591 /* This business exists because menu events "happen" when | |
2592 menubar_selection_callback() is called from somewhere deep | |
2593 within XtAppProcessEvent in emacs_Xt_next_event(). The | |
2594 callback needs to terminate the modal loop in that function | |
2595 or else it will continue waiting until another event is | |
2596 received. | |
2597 | |
2598 Same business applies to scrollbar events. */ | |
2599 | |
2600 void | |
2601 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function, | |
2602 Lisp_Object object) | |
2603 { | |
2604 Lisp_Object event = Fmake_event (Qnil, Qnil); | |
2605 | |
934 | 2606 XSET_EVENT_TYPE (event, misc_user_event); |
2607 XSET_EVENT_CHANNEL (event, channel); | |
1204 | 2608 XSET_EVENT_MISC_USER_FUNCTION (event, function); |
2609 XSET_EVENT_MISC_USER_OBJECT (event, object); | |
2610 enqueue_dispatch_event (event); | |
428 | 2611 } |
2612 | |
2613 static void | |
440 | 2614 emacs_Xt_next_event (Lisp_Event *emacs_event) |
428 | 2615 { |
2616 we_didnt_get_an_event: | |
2617 | |
2618 while (NILP (dispatch_event_queue) && | |
2619 !completed_timeouts && | |
2620 !fake_event_occurred && | |
2621 !process_events_occurred && | |
2622 !tty_events_occurred) | |
2623 { | |
1268 | 2624 if (in_modal_loop) |
2625 { | |
2626 /* in_modal_loop gets set when we are in the process of | |
2627 dispatching an event (more specifically, when we are inside of | |
2628 a menu callback -- if we get here, it means we called a filter | |
2629 and the filter did something that tried to fetch an event, | |
2630 e.g. sit-for). In such a case, we cannot safely dispatch any | |
2631 more events. This is because those dispatching those events | |
2632 could cause lwlib to be entered reentranty, specifically if | |
2633 they are menu events. lwlib is not designed for this and will | |
2634 crash. We used to see this crash constantly as a result of | |
2635 QUIT checking, but QUIT will not now function in a modal loop. | |
2636 However, we can't just not process any events at all, because | |
2637 that will make sit-for etc. hang. So we go ahead and process | |
2638 the non-X kinds of events. */ | |
1292 | 2639 #ifdef WIN32_ANY |
2640 mswindows_is_blocking = 1; | |
2641 #endif | |
2642 XtAppProcessEvent (Xt_app_con, XtIMTimer | XtIMAlternateInput); | |
2643 #ifdef WIN32_ANY | |
2644 mswindows_is_blocking = 0; | |
2645 #endif | |
1268 | 2646 } |
428 | 2647 else |
2648 { | |
1268 | 2649 /* Stupid logic in XtAppProcessEvent() dictates that, if process |
2650 events and X events are both available, the process event gets | |
2651 taken first. This will cause an infinite loop if we're being | |
2652 called from Fdiscard_input(). | |
2653 */ | |
2654 | |
2655 if (XtAppPending (Xt_app_con) & XtIMXEvent) | |
2656 XtAppProcessEvent (Xt_app_con, XtIMXEvent); | |
2657 else | |
428 | 2658 { |
1268 | 2659 Lisp_Object devcons, concons; |
2660 | |
2661 /* We're about to block. Xt has a bug in it (big surprise, | |
2662 there) in that it blocks using select() and doesn't | |
2663 flush the Xlib output buffers (XNextEvent() does this | |
2664 automatically before blocking). So it's necessary | |
2665 for us to do this ourselves. If we don't do it, then | |
2666 display output may not be seen until the next time | |
2667 an X event is received. (This happens esp. with | |
2668 subprocess output that gets sent to a visible buffer.) | |
2669 | |
2670 #### The above comment may not have any validity. */ | |
2671 | |
2672 DEVICE_LOOP_NO_BREAK (devcons, concons) | |
2673 { | |
2674 struct device *d; | |
2675 d = XDEVICE (XCAR (devcons)); | |
2676 | |
2677 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d)) | |
2678 /* emacs may be exiting */ | |
2679 XFlush (DEVICE_X_DISPLAY (d)); | |
2680 } | |
1292 | 2681 #ifdef WIN32_ANY |
2682 mswindows_is_blocking = 1; | |
2683 #endif | |
1268 | 2684 XtAppProcessEvent (Xt_app_con, XtIMAll); |
1292 | 2685 #ifdef WIN32_ANY |
2686 mswindows_is_blocking = 0; | |
2687 #endif | |
428 | 2688 } |
2689 } | |
2690 } | |
2691 | |
2692 if (!NILP (dispatch_event_queue)) | |
2693 { | |
2694 Lisp_Object event, event2; | |
793 | 2695 event2 = wrap_event (emacs_event); |
1204 | 2696 event = dequeue_dispatch_event (); |
428 | 2697 Fcopy_event (event, event2); |
2698 Fdeallocate_event (event); | |
2699 } | |
2700 else if (tty_events_occurred) | |
2701 { | |
2702 if (!Xt_tty_to_emacs_event (emacs_event)) | |
2703 goto we_didnt_get_an_event; | |
2704 } | |
2705 else if (completed_timeouts) | |
2706 Xt_timeout_to_emacs_event (emacs_event); | |
2707 else if (fake_event_occurred) | |
2708 { | |
2709 /* A dummy event, so that a cycle of the command loop will occur. */ | |
2710 fake_event_occurred = 0; | |
2711 /* eval events have nil as channel */ | |
934 | 2712 set_event_type (emacs_event, eval_event); |
1204 | 2713 SET_EVENT_EVAL_FUNCTION (emacs_event, Qidentity); |
2714 SET_EVENT_EVAL_OBJECT (emacs_event, Qnil); | |
428 | 2715 } |
2716 else /* if (process_events_occurred) */ | |
2717 Xt_process_to_emacs_event (emacs_event); | |
2718 | |
2719 /* No need to call XFilterEvent; Xt does it for us */ | |
2720 } | |
2721 | |
2722 void | |
2286 | 2723 emacs_Xt_event_handler (Widget UNUSED (wid), |
2724 XtPointer UNUSED (closure), | |
428 | 2725 XEvent *event, |
2286 | 2726 Boolean *UNUSED (continue_to_dispatch)) |
428 | 2727 { |
2728 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil); | |
2729 | |
2730 #ifdef DEBUG_XEMACS | |
442 | 2731 if (debug_x_events > 0) |
788 | 2732 describe_event (event, Qexternal_debugging_output); |
428 | 2733 #endif /* DEBUG_XEMACS */ |
2734 if (x_event_to_emacs_event (event, XEVENT (emacs_event))) | |
1204 | 2735 enqueue_dispatch_event (emacs_event); |
428 | 2736 else |
2737 Fdeallocate_event (emacs_event); | |
2738 } | |
2739 | |
2740 | |
2741 /************************************************************************/ | |
1204 | 2742 /* input pending */ |
428 | 2743 /************************************************************************/ |
2744 | |
2745 static void | |
1204 | 2746 emacs_Xt_drain_queue (void) |
428 | 2747 { |
2748 Lisp_Object devcons, concons; | |
1268 | 2749 if (!in_modal_loop) |
428 | 2750 { |
1268 | 2751 CONSOLE_LOOP (concons) |
428 | 2752 { |
1268 | 2753 struct console *con = XCONSOLE (XCAR (concons)); |
2754 if (!con->input_enabled) | |
2755 continue; | |
2756 | |
2757 CONSOLE_DEVICE_LOOP (devcons, con) | |
1204 | 2758 { |
1268 | 2759 struct device *d; |
2760 Display *display; | |
2761 d = XDEVICE (XCAR (devcons)); | |
2762 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d)) | |
2763 { | |
2764 display = DEVICE_X_DISPLAY (d); | |
2765 while (XEventsQueued (display, QueuedAfterReading)) | |
2766 XtAppProcessEvent (Xt_app_con, XtIMXEvent); | |
2767 } | |
1204 | 2768 } |
428 | 2769 } |
1268 | 2770 /* |
2771 while (XtAppPending (Xt_app_con) & XtIMXEvent) | |
2772 XtAppProcessEvent (Xt_app_con, XtIMXEvent); | |
2773 */ | |
428 | 2774 } |
1268 | 2775 |
2776 #ifdef HAVE_TTY | |
1204 | 2777 drain_tty_devices (); |
428 | 2778 #endif |
2779 } | |
2780 | |
1204 | 2781 int |
2782 check_if_pending_expose_event (struct device *dev) | |
2783 { | |
2784 Display *d = DEVICE_X_DISPLAY (dev); | |
2785 Lisp_Object event; | |
2786 | |
2787 emacs_Xt_drain_queue (); | |
2788 | |
2789 EVENT_CHAIN_LOOP (event, dispatch_event_queue) | |
2790 if (XEVENT_TYPE (event) == magic_event) | |
2791 { | |
2792 XEvent *xev = &XEVENT_MAGIC_X_EVENT (event); | |
2793 if (xev->type == Expose && | |
2794 xev->xexpose.display == d) | |
2795 return 1; | |
2796 } | |
2797 | |
2798 return 0; | |
2799 } | |
2800 | |
442 | 2801 static int |
2802 emacs_Xt_current_event_timestamp (struct console *c) | |
2803 { | |
2804 /* semi-yuck. */ | |
2805 Lisp_Object devs = CONSOLE_DEVICE_LIST (c); | |
2806 | |
2807 if (NILP (devs)) | |
2808 return 0; | |
2809 else | |
2810 { | |
2811 struct device *d = XDEVICE (XCAR (devs)); | |
2812 return DEVICE_X_LAST_SERVER_TIMESTAMP (d); | |
2813 } | |
2814 } | |
2815 | |
428 | 2816 |
2817 /************************************************************************/ | |
2818 /* replacement for standard string-to-pixel converter */ | |
2819 /************************************************************************/ | |
2820 | |
2821 /* This was constructed by ripping off the standard string-to-pixel | |
2822 converter from Converters.c in the Xt source code and modifying | |
2823 appropriately. */ | |
2824 | |
2825 #if 0 | |
2826 | |
2827 /* This is exported by the Xt library (at least by mine). If this | |
2828 isn't the case somewhere, rename this appropriately and remove | |
2829 the '#if 0'. Note, however, that I got "unknown structure" | |
2830 errors when I tried this. */ | |
2831 XtConvertArgRec Const colorConvertArgs[] = { | |
440 | 2832 { XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen), |
2833 sizeof (Screen *) }, | |
2834 { XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap), | |
2835 sizeof (Colormap) } | |
428 | 2836 }; |
2837 | |
2838 #endif | |
2839 | |
2840 #define done(type, value) \ | |
2841 if (toVal->addr != NULL) { \ | |
2842 if (toVal->size < sizeof(type)) { \ | |
2843 toVal->size = sizeof(type); \ | |
2844 return False; \ | |
2845 } \ | |
2846 *(type*)(toVal->addr) = (value); \ | |
2847 } else { \ | |
2848 static type static_val; \ | |
2849 static_val = (value); \ | |
2850 toVal->addr = (XPointer)&static_val; \ | |
2851 } \ | |
2852 toVal->size = sizeof(type); \ | |
2853 return True /* Caller supplies `;' */ | |
2854 | |
2855 /* JH: We use this because I think there's a possibility this | |
2856 is called before the device is properly set up, in which case | |
2857 I don't want to abort. */ | |
2858 extern struct device *get_device_from_display_1 (Display *dpy); | |
2859 | |
2860 static | |
2861 Boolean EmacsXtCvtStringToPixel ( | |
2862 Display *dpy, | |
2863 XrmValuePtr args, | |
2864 Cardinal *num_args, | |
2865 XrmValuePtr fromVal, | |
2866 XrmValuePtr toVal, | |
2867 XtPointer *closure_ret) | |
2868 { | |
2869 String str = (String)fromVal->addr; | |
2870 XColor screenColor; | |
2871 XColor exactColor; | |
2872 Screen *screen; | |
2873 Colormap colormap; | |
2874 Visual *visual; | |
2875 struct device *d; | |
2876 Status status; | |
2877 String params[1]; | |
2878 Cardinal num_params = 1; | |
2879 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy); | |
2880 | |
2881 if (*num_args != 2) { | |
2882 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel", | |
2883 "XtToolkitError", | |
2884 "String to pixel conversion needs screen and colormap arguments", | |
2885 (String *)NULL, (Cardinal *)NULL); | |
2886 return False; | |
2887 } | |
2888 | |
2889 screen = *((Screen **) args[0].addr); | |
2890 colormap = *((Colormap *) args[1].addr); | |
2891 | |
2892 /* The original uses the private function CompareISOLatin1(). | |
2893 Use XmuCompareISOLatin1() if you want, but I don't think it | |
2894 makes any difference here. */ | |
2895 if (strcmp(str, XtDefaultBackground) == 0) { | |
2896 *closure_ret = False; | |
2897 /* This refers to the display's "*reverseVideo" resource. | |
2898 These display resources aren't documented anywhere that | |
2899 I can find, so I'm going to ignore this. */ | |
2900 /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */ | |
2901 done(Pixel, WhitePixelOfScreen(screen)); | |
2902 } | |
2903 if (strcmp(str, XtDefaultForeground) == 0) { | |
2904 *closure_ret = False; | |
2905 /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */ | |
2906 done(Pixel, BlackPixelOfScreen(screen)); | |
2907 } | |
2908 | |
2909 /* Originally called XAllocNamedColor() here. */ | |
2910 if ((d = get_device_from_display_1(dpy))) { | |
2911 visual = DEVICE_X_VISUAL(d); | |
2912 if (colormap != DEVICE_X_COLORMAP(d)) { | |
442 | 2913 XtAppWarningMsg(the_app_con, "weirdColormap", "cvtStringToPixel", |
428 | 2914 "XtToolkitWarning", |
442 | 2915 "The colormap passed to cvtStringToPixel doesn't match the one registered to the device.\n", |
428 | 2916 NULL, 0); |
2917 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor); | |
2918 } else { | |
2919 status = XParseColor (dpy, colormap, (char*)str, &screenColor); | |
2920 if (status) { | |
3094 | 2921 status = x_allocate_nearest_color (dpy, colormap, visual, &screenColor); |
428 | 2922 } |
2923 } | |
2924 } else { | |
2925 /* We haven't set up this device totally yet, so just punt */ | |
2926 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor); | |
2927 } | |
2928 if (status == 0) { | |
2929 params[0] = str; | |
2930 /* Server returns a specific error code but Xlib discards it. Ugh */ | |
2931 if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str, | |
2932 &exactColor, &screenColor)) { | |
2933 XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel", | |
2934 "XtToolkitError", | |
2935 "Cannot allocate colormap entry for \"%s\"", | |
2936 params, &num_params); | |
2937 | |
2938 } else { | |
2939 XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel", | |
2940 "XtToolkitError", | |
2941 "Color name \"%s\" is not defined", params, &num_params); | |
2942 } | |
2943 | |
2944 *closure_ret = False; | |
2945 return False; | |
2946 } else { | |
2947 *closure_ret = (char*)True; | |
2948 done(Pixel, screenColor.pixel); | |
2949 } | |
2950 } | |
2951 | |
2952 /* ARGSUSED */ | |
2953 static void EmacsFreePixel ( | |
2954 XtAppContext app, | |
2955 XrmValuePtr toVal, | |
2956 XtPointer closure, | |
2957 XrmValuePtr args, | |
2958 Cardinal *num_args) | |
2959 { | |
2960 if (*num_args != 2) { | |
2961 XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError", | |
2962 "Freeing a pixel requires screen and colormap arguments", | |
2963 (String *)NULL, (Cardinal *)NULL); | |
2964 return; | |
2965 } | |
2966 | |
2967 if (closure) { | |
2968 Screen *screen = *((Screen **) args[0].addr); | |
2969 Colormap colormap = *((Colormap *) args[1].addr); | |
2970 XFreeColors(DisplayOfScreen(screen), colormap, | |
2971 (unsigned long*)toVal->addr, 1, (unsigned long)0); | |
2972 } | |
2973 } | |
2974 | |
2975 | |
2976 /************************************************************************/ | |
442 | 2977 /* handle focus changes for native widgets */ |
2978 /************************************************************************/ | |
2979 static void | |
2980 emacs_Xt_event_widget_focus_in (Widget w, | |
2981 XEvent *event, | |
2286 | 2982 String *UNUSED (params), |
2983 Cardinal *UNUSED (num_params)) | |
442 | 2984 { |
853 | 2985 struct frame *f = |
442 | 2986 x_any_widget_or_parent_to_frame (get_device_from_display (event->xany.display), w); |
2987 | |
2988 XtSetKeyboardFocus (FRAME_X_SHELL_WIDGET (f), w); | |
2989 } | |
2990 | |
2991 static void | |
2286 | 2992 emacs_Xt_event_widget_focus_out (Widget UNUSED (w), |
2993 XEvent *UNUSED (event), | |
2994 String *UNUSED (params), | |
2995 Cardinal *UNUSED (num_params)) | |
442 | 2996 { |
2997 } | |
2998 | |
2999 static XtActionsRec widgetActionsList[] = | |
3000 { | |
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
3001 { (String) "widget-focus-in", emacs_Xt_event_widget_focus_in }, |
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
3002 { (String) "widget-focus-out", emacs_Xt_event_widget_focus_out }, |
442 | 3003 }; |
3004 | |
3005 static void | |
3006 emacs_Xt_event_add_widget_actions (XtAppContext ctx) | |
3007 { | |
3008 XtAppAddActions (ctx, widgetActionsList, 2); | |
3009 } | |
3010 | |
3011 | |
3012 /************************************************************************/ | |
428 | 3013 /* initialization */ |
3014 /************************************************************************/ | |
3015 | |
3016 void | |
3017 syms_of_event_Xt (void) | |
3018 { | |
563 | 3019 DEFSYMBOL (Qsans_modifiers); |
3020 DEFSYMBOL (Qself_insert_command); | |
428 | 3021 } |
3022 | |
3023 void | |
3024 reinit_vars_of_event_Xt (void) | |
3025 { | |
1204 | 3026 Xt_event_stream = xnew_and_zero (struct event_stream); |
428 | 3027 Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p; |
1204 | 3028 Xt_event_stream->force_event_pending_cb= emacs_Xt_force_event_pending; |
428 | 3029 Xt_event_stream->next_event_cb = emacs_Xt_next_event; |
3030 Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event; | |
788 | 3031 Xt_event_stream->format_magic_event_cb = emacs_Xt_format_magic_event; |
3032 Xt_event_stream->compare_magic_event_cb= emacs_Xt_compare_magic_event; | |
3033 Xt_event_stream->hash_magic_event_cb = emacs_Xt_hash_magic_event; | |
428 | 3034 Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout; |
3035 Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout; | |
3036 Xt_event_stream->select_console_cb = emacs_Xt_select_console; | |
3037 Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console; | |
3038 Xt_event_stream->select_process_cb = emacs_Xt_select_process; | |
3039 Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process; | |
1204 | 3040 Xt_event_stream->drain_queue_cb = emacs_Xt_drain_queue; |
853 | 3041 Xt_event_stream->create_io_streams_cb = emacs_Xt_create_io_streams; |
3042 Xt_event_stream->delete_io_streams_cb = emacs_Xt_delete_io_streams; | |
442 | 3043 Xt_event_stream->current_event_timestamp_cb = |
3044 emacs_Xt_current_event_timestamp; | |
428 | 3045 |
3046 the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype); | |
3047 | |
3048 last_quit_check_signal_tick_count = 0; | |
3049 | |
3050 /* this function only makes safe calls */ | |
3051 init_what_input_once (); | |
3052 } | |
3053 | |
3054 void | |
3055 vars_of_event_Xt (void) | |
3056 { | |
3057 DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /* | |
3058 *Non-nil means to allow synthetic events. Nil means they are ignored. | |
3059 Beware: allowing emacs to process SendEvents opens a big security hole. | |
3060 */ ); | |
3061 x_allow_sendevents = 0; | |
3062 | |
3063 #ifdef DEBUG_XEMACS | |
442 | 3064 DEFVAR_INT ("debug-x-events", &debug_x_events /* |
428 | 3065 If non-zero, display debug information about X events that XEmacs sees. |
3066 Information is displayed on stderr. Currently defined values are: | |
3067 | |
3068 1 == non-verbose output | |
3069 2 == verbose output | |
3070 */ ); | |
442 | 3071 debug_x_events = 0; |
428 | 3072 #endif |
3171 | 3073 DEFVAR_LISP ("x-us-keymap-description", &Vx_us_keymap_description /* |
3074 X11-specific vector describing the current keyboard hardware, and how to map | |
3075 from its keycodes to those alphanumeric and punctuation characters that | |
3076 would be produced by it if a US layout were configured in software. | |
3077 | |
3078 We use this to make possible the usage of standard key bindings on keyboards | |
3079 where the keys that those bindings assume are not available; for example, on | |
3080 a Russian keyboard, one can type C-Cyrillic_che C-Cyrillic_a and have XEmacs | |
3081 use the binding for C-x C-f, rather than give an error message that | |
3082 C-Cyrillic_che C-Cyrillic_a is not bound. | |
3083 | |
3084 Entries are either nil, which means the corresponding key code does not map | |
3085 to a non-function key in the US layout, a single character, meaning it maps to | |
3086 that character, or a vector of two characters, the first indicating the | |
3087 unshifted mapping, the second the shifted mapping for the US layout. | |
3088 | |
3089 `x-us-keymap-first-keycode' tells XEmacs the keycode of the first entry in | |
3090 this vector. | |
3091 */ ); | |
3092 Vx_us_keymap_description = Qnil; | |
3093 | |
3094 DEFVAR_INT ("x-us-keymap-first-keycode", &Vx_us_keymap_first_keycode /* | |
3095 The X11 keycode that the first entry in `x-us-keymap-description' | |
3096 corresponds to. See the documentation for that variable. | |
3097 | |
3098 The X11 documentation for XDisplayKeycodes says this can never be less than | |
3099 8, but XEmacs doesn't enforce any limitation on what you set it to. | |
3100 */ ); | |
3101 Vx_us_keymap_first_keycode = 0; | |
428 | 3102 } |
3103 | |
3104 /* This mess is a hack that patches the shell widget to treat visual inheritance | |
3105 the same as colormap and depth inheritance */ | |
3106 | |
3107 static XtInitProc orig_shell_init_proc; | |
3108 | |
2956 | 3109 static void ShellVisualPatch(Widget wanted, Widget new_, |
428 | 3110 ArgList args, Cardinal *num_args) |
3111 { | |
3112 Widget p; | |
2956 | 3113 ShellWidget w = (ShellWidget) new_; |
428 | 3114 |
3115 /* first, call the original setup */ | |
2956 | 3116 (*orig_shell_init_proc)(wanted, new_, args, num_args); |
428 | 3117 |
3118 /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */ | |
3119 if (w->shell.visual == CopyFromParent) { | |
3120 p = XtParent(w); | |
3121 while (p && !XtIsShell(p)) p = XtParent(p); | |
3122 if (p) w->shell.visual = ((ShellWidget)p)->shell.visual; | |
3123 } | |
3124 } | |
3125 | |
3126 void | |
3127 init_event_Xt_late (void) /* called when already initialized */ | |
3128 { | |
3129 timeout_id_tick = 1; | |
3130 pending_timeouts = 0; | |
3131 completed_timeouts = 0; | |
3132 | |
3133 event_stream = Xt_event_stream; | |
3134 | |
3135 XtToolkitInitialize (); | |
3136 Xt_app_con = XtCreateApplicationContext (); | |
3137 XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources); | |
3138 | |
442 | 3139 /* In select-x.c */ |
428 | 3140 x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000); |
3141 XSetErrorHandler (x_error_handler); | |
3142 XSetIOErrorHandler (x_IO_error_handler); | |
3143 | |
442 | 3144 #ifndef WIN32_NATIVE |
428 | 3145 XtAppAddInput (Xt_app_con, signal_event_pipe[0], |
3146 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */), | |
3147 Xt_what_callback, 0); | |
3148 #endif | |
3149 | |
3150 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel, | |
3151 EmacsXtCvtStringToPixel, | |
3152 (XtConvertArgList) colorConvertArgs, | |
3153 2, XtCacheByDisplay, EmacsFreePixel); | |
3154 | |
3155 #ifdef XIM_XLIB | |
3156 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles, | |
3157 EmacsXtCvtStringToXIMStyles, | |
3158 NULL, 0, | |
3159 XtCacheByDisplay, EmacsFreeXIMStyles); | |
3160 #endif /* XIM_XLIB */ | |
442 | 3161 /* Add extra actions to native widgets to handle focus and friends. */ |
3162 emacs_Xt_event_add_widget_actions (Xt_app_con); | |
428 | 3163 |
3164 /* insert the visual inheritance patch/hack described above */ | |
3165 orig_shell_init_proc = shellClassRec.core_class.initialize; | |
3166 shellClassRec.core_class.initialize = ShellVisualPatch; | |
3167 | |
3168 } |