#include "lisp.h"
-/* On 4.3 this loses if it comes after xterm.h. */
+/* On 4.3 these lose if they come after xterm.h. */
+#include <stdio.h>
#include <signal.h>
/* This may include sys/types.h, and that somehow loses
#include "systime.h"
#include <fcntl.h>
-#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <setjmp.h>
/* Which modifier keys are on which modifier bits?
With each keystroke, X returns eight bits indicating which modifier
- keys were held down when the key was pressed. The low three bits
- indicate the state of the shift, shift lock, caps lock, and control
- keys; their interpretation is fixed. However, the interpretation
- of the other five modifier bits depends on what keys are attached
+ keys were held down when the key was pressed. The interpretation
+ of the top five modifier bits depends on what keys are attached
to them. If the Meta_L and Meta_R keysyms are on mod5, then mod5
is the meta bit.
x_meta_mod_mask is a mask containing the bits used for the meta key.
It may have more than one bit set, if more than one modifier bit
has meta keys on it. Basically, if EVENT is a KeyPress event,
- the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0. */
-static int x_meta_mod_mask;
+ the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0.
+
+ x_shift_lock_mask is LockMask if the XK_Shift_Lock keysym is on the
+ lock modifier bit, or zero otherwise. Non-alphabetic keys should
+ only be affected by the lock modifier bit if XK_Shift_Lock is in
+ use; XK_Caps_Lock should only affect alphabetic keys. With this
+ arrangement, the lock modifier should shift the character if
+ (EVENT.state & x_shift_lock_mask) != 0. */
+static int x_meta_mod_mask, x_shift_lock_mask;
/* Initialize mode_switch_bit and modifier_meaning. */
static void
x_find_modifier_meanings ()
{
- KeyCode min_code, max_code;
+ int min_code, max_code;
KeySym *syms;
int syms_per_code;
XModifierKeymap *mods;
+ int alt_mod_mask = 0;
x_meta_mod_mask = 0;
+ x_shift_lock_mask = 0;
XDisplayKeycodes (x_current_display, &min_code, &max_code);
syms = XGetKeyboardMapping (x_current_display,
&syms_per_code);
mods = XGetModifierMapping (x_current_display);
- /* If CapsLock is on the lock modifier, then only letters should be
- affected; since XLookupString takes care of this for us, the lock
- modifier shouldn't set shift_modifier. However, if ShiftLock is
- on the lock modifier, then lock should mean shift. */
+ /* Scan the modifier table to see which modifier bits the Meta and
+ Alt keysyms are on. */
{
int row, col; /* The row and column in the modifier table. */
for (code_col = 0; code_col < syms_per_code; code_col++)
{
- int sym = syms[(code * syms_per_code) + code_col];
+ int sym = syms[((code - min_code) * syms_per_code) + code_col];
- if (sym == XK_Meta_L || sym == XK_Meta_R)
+ switch (sym)
{
+ case XK_Meta_L:
+ case XK_Meta_R:
x_meta_mod_mask |= (1 << row);
break;
+
+ case XK_Alt_L:
+ case XK_Alt_R:
+ alt_mod_mask |= (1 << row);
+ break;
+
+ case XK_Shift_Lock:
+ /* Ignore this if it's not on the lock modifier. */
+ if ((1 << row) == LockMask)
+ x_shift_lock_mask = LockMask;
+ break;
}
}
}
}
}
+ /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
+ if (! x_meta_mod_mask)
+ x_meta_mod_mask = alt_mod_mask;
+
XFree ((char *) syms);
- XFreeModifierMap (mods);
+ XFreeModifiermap (mods);
}
/* Convert a set of X modifier bits to the proper form for a
struct input_event modifiers value. */
-static Lisp_Object
+static unsigned int
x_convert_modifiers (state)
unsigned int state;
{
- return ( ((state & (ShiftMask | LockMask)) ? shift_modifier : 0)
- | ((state & ControlMask) ? ctrl_modifier : 0)
- | ((state & x_meta_mod_mask) ? meta_modifier : 0));
+ return ( ((state & (ShiftMask | x_shift_lock_mask)) ? shift_modifier : 0)
+ | ((state & ControlMask) ? ctrl_modifier : 0)
+ | ((state & x_meta_mod_mask) ? meta_modifier : 0));
}
extern struct frame *x_window_to_scrollbar ();
XSET (result->code, Lisp_Int, event->button);
result->timestamp = event->time;
result->modifiers = (x_convert_modifiers (event->state)
- | (event->type == ButtonRelease ? up_modifier : 0));
+ | (event->type == ButtonRelease
+ ? up_modifier
+ : down_modifier));
/* Notice if the mouse is still grabbed. */
if (event->type == ButtonPress)
Vmouse_depressed = Qnil;
}
- if (part) /* Scrollbar event */
+ if (! NILP (part)) /* Scrollbar event */
{
int pos, len;
pos = event->y - (f->display.x->v_scrollbar_width - 2);
- XSET (x_mouse_x, Lisp_Int, pos);
+ x_mouse_x = pos;
len = ((FONT_HEIGHT (f->display.x->font) * f->height)
+ f->display.x->internal_border_width
- (2 * (f->display.x->v_scrollbar_width - 2)));
- XSET (x_mouse_y, Lisp_Int, len);
+ x_mouse_y = len;
result->kind = scrollbar_click;
result->part = part;
pixel_to_glyph_coords (f, event->x, event->y, &column, &row, NULL);
result->kind = mouse_click;
- result->x = column;
- result->y = row;
+ XFASTINT (result->x) = column;
+ XFASTINT (result->y) = row;
result->frame = f;
}
}
sometimes don't work. */
static Time enter_timestamp;
+/* This holds the state XLookupString needs to implement dead keys
+ and other tricks known as "compose processing". _X Window System_
+ says that a portable program can't use this, but Stephen Gildea assures
+ me that letting the compiler initialize it to zeros will work okay.
+
+ This must be defined outside of XTread_socket, for the same reasons
+ given for enter_timestamp, above. */
+static XComposeStatus compose_status;
+
/* Communication with window managers. */
Atom Xatom_wm_protocols;
WAITP is nonzero if we should block until input arrives.
EXPECTED is nonzero if the caller knows input is available. */
-Lisp_Object
+int
XTread_socket (sd, bufp, numchars, waitp, expected)
register int sd;
register struct input_event *bufp;
if (f != 0)
{
KeySym keysym;
- XComposeStatus status;
char copy_buffer[80];
int modifiers = event.xkey.state;
just clear the meta-key flag to get the 'pure' character. */
event.xkey.state &= ~Mod1Mask;
- /* This will have to go some day... */
- nbytes = XLookupString (&event.xkey,
- copy_buffer,
- 80,
- &keysym,
- &status);
+ /* This will have to go some day... */
+ nbytes =
+ XLookupString (&event.xkey, copy_buffer, 80, &keysym,
+ &compose_status);
/* Strip off the vendor-specific keysym bit, and take a shot
at recognizing the codes. HP servers have extra keysyms
if (nbytes == 1)
{
- if (modifiers & Mod1Mask)
+ if (modifiers & x_meta_mod_mask)
*copy_buffer |= METABIT;
bufp->kind = ascii_keystroke;
XSET (bufp->code, Lisp_Int, *copy_buffer);
if (f)
if (!x_focus_frame || (f == x_focus_frame))
construct_mouse_click (&emacs_event,
- &event, f, 0, 0);
+ &event, f, Qnil, 0);
else
continue;
else
#endif /* ! defined (HAVE_X11) */
case MappingNotify:
- if (event.xmapping.request == MappingKeyboard)
- /* Someone has changed the keyboard mapping - flush the
- local cache. */
- XRefreshKeyboardMapping (&event.xmapping);
+ /* Someone has changed the keyboard mapping - update the
+ local cache. */
+ switch (event.xmapping.request)
+ {
+ case MappingModifier:
+ x_find_modifier_meanings ();
+ /* This is meant to fall through. */
+ case MappingKeyboard:
+ XRefreshKeyboardMapping (&event.xmapping);
+ }
break;
default:
#ifdef HAVE_X11
if (f->display.x->left_pos < 0)
f->display.x->left_pos
- = XINT (x_screen_width) - PIXEL_WIDTH (f) + f->display.x->left_pos;
+ = x_screen_width - PIXEL_WIDTH (f) + f->display.x->left_pos;
if (f->display.x->top_pos < 0)
f->display.x->top_pos
- = XINT (x_screen_height) - PIXEL_HEIGHT (f) + f->display.x->top_pos;
+ = x_screen_height - PIXEL_HEIGHT (f) + f->display.x->top_pos;
#else /* ! defined (HAVE_X11) */
WINDOWINFO_TYPE parentinfo;