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