#include "blocktype.h"
#include "buffer.h"
-#include "commands.h"
#include "console.h"
#include "console-tty.h"
#include "events.h"
#include "events-mod.h"
static void enqueue_Xt_dispatch_event (Lisp_Object event);
+static void handle_focus_event_1 (struct frame *f, int in_p);
static struct event_stream *Xt_event_stream;
Display *display = DEVICE_X_DISPLAY (d);
struct x_device *xd = DEVICE_X_DATA (d);
KeySym *keysym, *keysym_end;
- Lisp_Object hashtable;
+ Lisp_Object hash_table;
int key_code_count, keysyms_per_code;
if (xd->x_keysym_map)
XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count,
&xd->x_keysym_map_keysyms_per_code);
- hashtable = xd->x_keysym_map_hashtable;
- if (HASHTABLEP (hashtable))
- Fclrhash (hashtable);
+ hash_table = xd->x_keysym_map_hash_table;
+ if (HASH_TABLEP (hash_table))
+ Fclrhash (hash_table);
else
- xd->x_keysym_map_hashtable = hashtable =
- make_lisp_hashtable (128, HASHTABLE_NONWEAK, HASHTABLE_EQUAL);
+ xd->x_keysym_map_hash_table = hash_table =
+ make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
for (keysym = xd->x_keysym_map,
keysyms_per_code = xd->x_keysym_map_keysyms_per_code,
Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[0], 0);
if (name)
{
- Fputhash (build_string (name), Qsans_modifiers, hashtable);
- Fputhash (sym, Qsans_modifiers, hashtable);
+ Fputhash (build_string (name), Qsans_modifiers, hash_table);
+ Fputhash (sym, Qsans_modifiers, hash_table);
}
}
{
char *name = XKeysymToString (keysym[j]);
Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[j], 0);
- if (name && NILP (Fgethash (sym, hashtable, Qnil)))
+ if (name && NILP (Fgethash (sym, hash_table, Qnil)))
{
- Fputhash (build_string (name), Qt, hashtable);
- Fputhash (sym, Qt, hashtable);
+ Fputhash (build_string (name), Qt, hash_table);
+ Fputhash (sym, Qt, hash_table);
}
}
}
x_init_modifier_mapping (struct device *d)
{
struct x_device *xd = DEVICE_X_DATA (d);
- xd->x_keysym_map_hashtable = Qnil;
+ xd->x_keysym_map_hash_table = Qnil;
xd->x_keysym_map = NULL;
xd->x_modifier_keymap = NULL;
x_reset_modifier_mapping (d);
emacs_Xt_mapping_action (Widget w, XEvent* event)
{
struct device *d = get_device_from_display (event->xany.display);
+
+ if (DEVICE_X_BEING_DELETED (d))
+ return;
#if 0
/* nyet. Now this is handled by Xt. */
XRefreshKeyboardMapping (&event->xmapping);
than passing in 0) to avoid crashes on German IRIX */
char dummy[256];
XLookupString (event, dummy, 200, &keysym, 0);
- return x_keysym_to_emacs_keysym (keysym, simple_p);
+ return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
+ ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
}
#endif /* ! XIM_MOTIF */
len = XmImMbLookupString (XtWindowToWidget (event->display, event->window),
event, bufptr, bufsiz, &keysym, &status);
#else /* XIM_XLIB */
- len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
+ if (xic)
+ len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
#endif /* HAVE_XIM */
#ifdef DEBUG_XEMACS
{
case XLookupKeySym:
case XLookupBoth:
- return x_keysym_to_emacs_keysym (keysym, simple_p);
+ return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
+ ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
case XLookupChars:
{
struct device *d = get_device_from_display (display);
struct x_device *xd = DEVICE_X_DATA (d);
+ if (DEVICE_X_BEING_DELETED (d))
+ /* #### Uh, is this 0 correct? */
+ return 0;
+
set_last_server_timestamp (d, x_event);
switch (x_event->type)
{
Lisp_Object keysym;
XKeyEvent *ev = &x_event->xkey;
- KeyCode keycode = ev->keycode;
-
- if (x_key_is_modifier_p (keycode, d)) /* it's a modifier key */
- return 0;
-
/* This used to compute the frame from the given X window and
store it here, but we really don't care about the frame. */
emacs_event->channel = DEVICE_CONSOLE (d);
keysym = x_to_emacs_keysym (&x_event->xkey, 0);
- /* If the emacs keysym is nil, then that means that the
- X keysym was NoSymbol, which probably means that
- we're in the midst of reading a Multi_key sequence,
- or a "dead" key prefix, or XIM input. Ignore it. */
+ /* If the emacs keysym is nil, then that means that the X
+ keysym was either a Modifier or NoSymbol, which
+ probably means that we're in the midst of reading a
+ Multi_key sequence, or a "dead" key prefix, or XIM
+ input. Ignore it. */
if (NILP (keysym))
return 0;
{
XButtonEvent *ev = &x_event->xbutton;
struct frame *frame = x_window_to_frame (d, ev->window);
+
if (! frame)
return 0; /* not for us */
XSETFRAME (emacs_event->channel, frame);
emacs_event->event.button.button = ev->button;
emacs_event->event.button.x = ev->x;
emacs_event->event.button.y = ev->y;
-
+ /* because we don't seem to get a FocusIn event for button clicks
+ when a widget-glyph is selected we will assume that we want the
+ focus if a button gets pressed. */
+ if (x_event->type == ButtonPress)
+ handle_focus_event_1 (frame, 1);
}
}
break;
emacs_event->timestamp = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
state=DndDragButtons(x_event);
-
+
if (state & ShiftMask) modifiers |= MOD_SHIFT;
if (state & ControlMask) modifiers |= MOD_CONTROL;
if (state & xd->MetaMask) modifiers |= MOD_META;
l_type = Qdragdrop_MIME;
l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
make_string ((Bufbyte *)"8bit", 4),
- make_ext_string ((Extbyte *)data,
+ make_ext_string ((Extbyte *)data,
strlen((char *)data),
FORMAT_CTEXT) ) );
break;
case DndLink:
case DndExe:
{
- char *hurl = dnd_url_hexify_string (data, "file:");
+ char *hurl = dnd_url_hexify_string ((char *) data, "file:");
l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
strlen (hurl)) );
case DndURL:
/* as it is a real URL it should already be escaped
and escaping again will break them (cause % is unsave) */
- l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
+ l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
strlen ((char *)data),
FORMAT_FILENAME) );
l_type = Qdragdrop_URL;
static void
handle_focus_event_1 (struct frame *f, int in_p)
{
+#if XtSpecificationRelease > 5
+ Widget focus_widget = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f));
+#endif
#ifdef HAVE_XIM
XIM_focus_event (f, in_p);
#endif /* HAVE_XIM */
Actually, we half handle it: we handle it as far as changing the
box cursor for redisplay, but we don't call any hooks or do any
select-frame stuff until after the sit-for.
- */
+
+ Unfortunately native widgets break the model because they grab
+ the keyboard focus and nothing sets it back again. I cannot find
+ any reasonable way to do this elsewhere so we assert here that
+ the keyboard focus is on the emacs text widget. Menus and dialogs
+ do this in their selection callback, but we don't want that since
+ a button having focus is legitimate. An edit field having focus
+ is mandatory. Weirdly you get a FocusOut event when you click in
+ a widget-glyph but you don't get a correspondng FocusIn when you
+ click in the frame. Why is this? */
+ if (in_p
+#if XtSpecificationRelease > 5
+ && FRAME_X_TEXT_WIDGET (f) != focus_widget
+#endif
+ )
+ {
+ lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f),
+ FRAME_X_TEXT_WIDGET (f));
+ }
+ /* do the generic event-stream stuff. */
{
Lisp_Object frm;
Lisp_Object conser;
void
emacs_Xt_handle_focus_event (XEvent *event)
{
+ struct device *d = get_device_from_display (event->xany.display);
+ struct frame *f;
+
+ if (DEVICE_X_BEING_DELETED (d))
+ return;
+
/*
* It's curious that we're using x_any_window_to_frame() instead
* of x_window_to_frame(). I don't know what the impact of this is.
*/
-
- struct frame *f =
- x_any_window_to_frame (get_device_from_display (event->xany.display),
- event->xfocus.window);
+ f = x_any_window_to_frame (d, event->xfocus.window);
if (!f)
/* focus events are sometimes generated just before
a frame is destroyed. */
/* Bleagh!!!!!! Apparently some window managers (e.g. MWM)
send synthetic MapNotify events when a window is first
- created, EVENT IF IT'S CREATED ICONIFIED OR INVISIBLE.
+ created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE.
Or something like that. We initially tried a different
solution below, but that ran into a different window-
manager bug.
XEvent *event = &emacs_event->event.magic.underlying_x_event;
struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
- if (!FRAME_LIVE_P (f))
+ if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
return;
switch (event->type)
break;
case Expose:
- x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
- event->xexpose.width, event->xexpose.height);
+ if (!check_for_ignored_expose (f, event->xexpose.x, event->xexpose.y,
+ event->xexpose.width, event->xexpose.height)
+ &&
+ !find_matching_subwindow (f, event->xexpose.x, event->xexpose.y,
+ event->xexpose.width, event->xexpose.height))
+ x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
+ event->xexpose.width, event->xexpose.height);
break;
case GraphicsExpose: /* This occurs when an XCopyArea's source area was
case FocusIn:
case FocusOut:
+
#ifdef EXTERNAL_WIDGET
/* External widget lossage: Ben said:
YUCK. The only way to make focus changes work properly is to
handle_client_message (f, event);
break;
- case VisibilityNotify: /* window visiblity has changed */
+ case VisibilityNotify: /* window visibility has changed */
if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
{
FRAME_X_TOTALLY_VISIBLE_P (f) =
/* Xt interval id's might not fit into an int (they're pointers, as it
happens), so we need to provide a conversion list. */
-struct Xt_timeout
+static struct Xt_timeout
{
int id;
XtIntervalId interval_id;
struct Xt_timeout *next;
} *pending_timeouts, *completed_timeouts;
-struct Xt_timeout_blocktype
+static struct Xt_timeout_blocktype
{
Blocktype_declare (struct Xt_timeout);
} *the_Xt_timeout_blocktype;
struct Xt_timeout *timeout, *t2;
timeout = NULL;
-
+
/* Find the timeout on the list of pending ones, if it's still there. */
if (pending_timeouts)
{
/* timeout events have nil as channel */
emacs_event->timestamp = 0; /* #### wrong!! */
emacs_event->event.timeout.interval_id = timeout->id;
+ emacs_event->event.timeout.function = Qnil;
+ emacs_event->event.timeout.object = Qnil;
Blocktype_free (the_Xt_timeout_blocktype, timeout);
}
Xt_process_to_emacs_event (struct Lisp_Event *emacs_event)
{
int i;
- Lisp_Object process;
assert (process_events_occurred > 0);
+
for (i = 0; i < MAXDESC; i++)
{
- process = filedesc_with_input[i];
+ Lisp_Object process = filedesc_with_input[i];
if (PROCESSP (process))
- break;
+ {
+ filedesc_with_input[i] = Qnil;
+ process_events_occurred--;
+ /* process events have nil as channel */
+ emacs_event->event_type = process_event;
+ emacs_event->timestamp = 0; /* #### */
+ emacs_event->event.process.process = process;
+ return;
+ }
}
- assert (i < MAXDESC);
- filedesc_with_input[i] = Qnil;
- process_events_occurred--;
- /* process events have nil as channel */
- emacs_event->event_type = process_event;
- emacs_event->timestamp = 0; /* #### */
- emacs_event->event.process.process = process;
+ abort ();
}
static void
{
Lisp_Object console;
int infd;
-#ifdef HAVE_GPM
- int mousefd;
-#endif
if (CONSOLE_X_P (con))
return; /* X consoles are automatically selected for when we
infd = event_stream_unixoid_select_console (con);
XSETCONSOLE (console, con);
select_filedesc (infd, console);
-#ifdef HAVE_GPM
- /* On a stream device (ie: noninteractive), bad things can happen. */
- if (EQ (CONSOLE_TYPE (con), Qtty)) {
- mousefd = CONSOLE_TTY_MOUSE_FD (con);
- /* We check filedesc_to_what_closure[fd] here because if you run
- ** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
- ** if you run gnuattach to connect to another TTY, it will fire up
- ** GPM again, and try to reselect the mouse fd. GPM uses the same
- ** fd for every connection apparently, and select_filedesc will
- ** fail its assertion if we try to select it twice.
- */
- if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
- select_filedesc (mousefd, console);
- }
- }
-#endif
}
static void
{
Lisp_Object console;
int infd;
-#ifdef HAVE_GPM
- int mousefd;
-#endif
if (CONSOLE_X_P (con))
return; /* X consoles are automatically selected for when we
infd = event_stream_unixoid_unselect_console (con);
XSETCONSOLE (console, con);
unselect_filedesc (infd);
-#ifdef HAVE_GPM
- /* On a stream device (ie: noninteractive), bad things can happen. */
- if (EQ (CONSOLE_TYPE (con), Qtty)) {
- mousefd = CONSOLE_TTY_MOUSE_FD (con);
- if (mousefd >= 0) {
- unselect_filedesc (mousefd);
- }
- }
-#endif
}
/* read an event from a tty, if one is available. Returns non-zero
}
void
-vars_of_event_Xt (void)
+reinit_vars_of_event_Xt (void)
{
- dispatch_event_queue = Qnil;
- staticpro (&dispatch_event_queue);
- dispatch_event_queue_tail = Qnil;
+ Xt_event_stream = xnew (struct event_stream);
+ Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p;
+ Xt_event_stream->next_event_cb = emacs_Xt_next_event;
+ Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
+ Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout;
+ Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout;
+ Xt_event_stream->select_console_cb = emacs_Xt_select_console;
+ Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console;
+ Xt_event_stream->select_process_cb = emacs_Xt_select_process;
+ Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process;
+ Xt_event_stream->quit_p_cb = emacs_Xt_quit_p;
+ Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
+ Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
+
+ the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
+
+ last_quit_check_signal_tick_count = 0;
/* this function only makes safe calls */
init_what_input_once ();
+}
- Xt_event_stream = xnew (struct event_stream);
- Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p;
- Xt_event_stream->next_event_cb = emacs_Xt_next_event;
- Xt_event_stream->handle_magic_event_cb= emacs_Xt_handle_magic_event;
- Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout;
- Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout;
- Xt_event_stream->select_console_cb = emacs_Xt_select_console;
- Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console;
- Xt_event_stream->select_process_cb = emacs_Xt_select_process;
- Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process;
- Xt_event_stream->quit_p_cb = emacs_Xt_quit_p;
- Xt_event_stream->create_stream_pair_cb= emacs_Xt_create_stream_pair;
- Xt_event_stream->delete_stream_pair_cb= emacs_Xt_delete_stream_pair;
+void
+vars_of_event_Xt (void)
+{
+ reinit_vars_of_event_Xt ();
+
+ dispatch_event_queue = Qnil;
+ staticpro (&dispatch_event_queue);
+ dispatch_event_queue_tail = Qnil;
+ pdump_wire (&dispatch_event_queue_tail);
DEFVAR_BOOL ("modifier-keys-are-sticky", &modifier_keys_are_sticky /*
*Non-nil makes modifier keys sticky.
*/ );
x_debug_events = 0;
#endif
-
- the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
-
- last_quit_check_signal_tick_count = 0;
}
/* This mess is a hack that patches the shell widget to treat visual inheritance