emacs: src/xterm.c comparison

comparison src/xterm.c @ 54173:03cb01738926

(x_focus_changed, x_detect_focus_change): Remove numchars arg. Always store event into bufp arg. Return nothing. Callers changed accordingly. (glyph_rect): Simplify. (STORE_KEYSYM_FOR_DEBUG): New macro. (SET_SAVED_MENU_EVENT): Use inev instead of bufp, etc. (current_bufp, current_numcharsp) [USE_GTK]: Remove. (current_hold_quit) [USE_GTK]: Add. (event_handler_gdk): Adapt to new handle_one_xevent. (handle_one_xevent): Remove bufp_r and numcharsp args. Add hold_quit arg. Rework to use just one, local, inev input_event. Store inev directly in fifo using kbd_buffer_store_event_hold. Update count in one place. Postpone call to gen_help_event until inev is stored; use new local do_help for this. Simplify handling of keysyms (consolidate common code). Fix bug where count was updated with nchars instead of nbytes. Remove local emacs_event in handing of ButtonPress event; just use inev instead (so no reason to copy it later). Remove `out' label. Rename label `ret' to `done'; add various `goto done' to clarify code flow in deeply nested blocks. (x_dispatch_event): Simplify as handle_one_xevent now calls kbd_buffer_store_event itself. (XTread_socket): Remove bufp_r and numcharsp args. Add hold_quit arg. Call handle_one_xevent with new arglist. Store event from x_session_check_input in fifo. [USE_GTK]: Setup current_hold_quit. Decrement handling_signal before unblocking input. (x_initialize) [USE_GTK]: Initialize current_count.

author	Kim F. Storm <storm@cua.dk>
date	Fri, 27 Feb 2004 23:49:48 +0000
parents	869ca316cdda
children	f6e4e454800a b44978264e1d

comparison

equal deleted inserted replaced

-:6851117e8d89
+:03cb01738926
 static void XTreset_terminal_modes P_ ((void));
 static void x_clear_frame P_ ((void));
 static void frame_highlight P_ ((struct frame *));
 static void frame_unhighlight P_ ((struct frame *));
 static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
-static int  x_focus_changed P_ ((int,
+static void  x_focus_changed P_ ((int, int, struct x_display_info *,
-int,
+				  struct frame *, struct input_event *));
-struct x_display_info *,
+static void x_detect_focus_change P_ ((struct x_display_info *,
-struct frame *,
+XEvent *, struct input_event *));
-struct input_event *,
-int));
-static int  x_detect_focus_change P_ ((struct x_display_info *,
-XEvent *,
-struct input_event *,
-int));
 static void XTframe_rehighlight P_ ((struct frame *));
 static void x_frame_rehighlight P_ ((struct x_display_info *));
 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
 				   enum text_cursor_kinds));
 					    enum scroll_bar_part *,
 					    Lisp_Object *, Lisp_Object *,
 					    unsigned long *));
 static void x_check_fullscreen P_ ((struct frame *));
 static void x_check_expected_move P_ ((struct frame *));
-static int handle_one_xevent P_ ((struct x_display_info *,
+static int handle_one_xevent P_ ((struct x_display_info *, XEvent *,
-XEvent *,
+				  int *, struct input_event *));
-struct input_event **,
-int *,
-int *));
 /* Flush display of frame F, or of all frames if F is null.  */
 static void
 x_frame_rehighlight (dpyinfo);
 }
 /* Handle FocusIn and FocusOut state changes for FRAME.
 If FRAME has focus and there exists more than one frame, puts
-a FOCUS_IN_EVENT into BUFP.
+a FOCUS_IN_EVENT into *BUFP.  */
-Returns number of events inserted into BUFP. */
+static void
-static int
+x_focus_changed (type, state, dpyinfo, frame, bufp)
-x_focus_changed (type, state, dpyinfo, frame, bufp, numchars)
 int type;
 int state;
 struct x_display_info *dpyinfo;
 struct frame *frame;
 struct input_event *bufp;
-int numchars;
+{
-{
-int nr_events = 0;
 if (type == FocusIn)
 {
 if (dpyinfo->x_focus_event_frame != frame)
 {
 x_new_focus_frame (dpyinfo, frame);
 dpyinfo->x_focus_event_frame = frame;
 /* Don't stop displaying the initial startup message
 for a switch-frame event we don't need.  */
-if (numchars > 0
+if (GC_NILP (Vterminal_frame)
-&& GC_NILP (Vterminal_frame)
 && GC_CONSP (Vframe_list)
 && !GC_NILP (XCDR (Vframe_list)))
 {
 bufp->kind = FOCUS_IN_EVENT;
 XSETFRAME (bufp->frame_or_window, frame);
-bufp->arg = Qnil;
-++bufp;
-numchars--;
-++nr_events;
 }
 }
 frame->output_data.x->focus_state |= state;
 #ifdef HAVE_X_I18N
 if (FRAME_XIC (frame))
 XUnsetICFocus (FRAME_XIC (frame));
 #endif
 }
-return nr_events;
 }
 /* The focus may have changed.  Figure out if it is a real focus change,
 by checking both FocusIn/Out and Enter/LeaveNotify events.
-Returns number of events inserted into BUFP. */
+Returns FOCUS_IN_EVENT event in *BUFP. */
-static int
+static void
-x_detect_focus_change (dpyinfo, event, bufp, numchars)
+x_detect_focus_change (dpyinfo, event, bufp)
 struct x_display_info *dpyinfo;
 XEvent *event;
 struct input_event *bufp;
-int numchars;
 {
 struct frame *frame;
 int nr_events = 0;
 frame = x_any_window_to_frame (dpyinfo, event->xany.window);
-if (! frame) return nr_events;
+if (! frame)
+return;
 switch (event->type)
 {
 case EnterNotify:
 case LeaveNotify:
 = focus_frame ? focus_frame->output_data.x->focus_state : 0;
 if (event->xcrossing.detail != NotifyInferior
 && event->xcrossing.focus
 && ! (focus_state & FOCUS_EXPLICIT))
-nr_events = x_focus_changed ((event->type == EnterNotify
+x_focus_changed ((event->type == EnterNotify ? FocusIn : FocusOut),
-? FocusIn : FocusOut),
+			   FOCUS_IMPLICIT,
-FOCUS_IMPLICIT,
+			   dpyinfo, frame, bufp);
-dpyinfo,
-frame,
-bufp,
-numchars);
 }
 break;
 case FocusIn:
 case FocusOut:
-nr_events = x_focus_changed (event->type,
+x_focus_changed (event->type,
-(event->xfocus.detail == NotifyPointer
+		       (event->xfocus.detail == NotifyPointer ?
-? FOCUS_IMPLICIT : FOCUS_EXPLICIT),
+			FOCUS_IMPLICIT : FOCUS_EXPLICIT),
-dpyinfo,
+		       dpyinfo, frame, bufp);
-frame,
-bufp,
-numchars);
 break;
 }
-return nr_events;
 }
 /* Handle an event saying the mouse has moved out of an Emacs frame.  */
 struct frame *f;
 int x, y;
 XRectangle *rect;
 {
 Lisp_Object window;
-int found = 0;
+struct window *w;
+struct glyph_row *r, *end_row;
 window = window_from_coordinates (f, x, y, 0, &x, &y, 0);
-if (!NILP (window))
+if (NILP (window))
-{
+return 0;
-struct window *w = XWINDOW (window);
-struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+w = XWINDOW (window);
-struct glyph_row *end = r + w->current_matrix->nrows - 1;
+r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+end_row = r + w->current_matrix->nrows - 1;
-for (; !found && r < end && r->enabled_p; ++r)
-	if (r->y >= y)
+for (; r < end_row && r->enabled_p; ++r)
-	  {
+{
-	    struct glyph *g = r->glyphs[TEXT_AREA];
+if (r->y >= y)
-	    struct glyph *end = g + r->used[TEXT_AREA];
+	{
-	    int gx;
+	  struct glyph *g = r->glyphs[TEXT_AREA];
+	  struct glyph *end = g + r->used[TEXT_AREA];
-	    for (gx = r->x; !found && g < end; gx += g->pixel_width, ++g)
+	  int gx = r->x;
-	      if (gx >= x)
+	  while (g < end && gx < x)
-		{
+	    gx += g->pixel_width, ++g;
-		  rect->width = g->pixel_width;
+	  if (g < end)
-		  rect->height = r->height;
+	    {
-		  rect->x = WINDOW_TO_FRAME_PIXEL_X (w, gx);
+	      rect->width = g->pixel_width;
-		  rect->y = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
+	      rect->height = r->height;
-		  found = 1;
+	      rect->x = WINDOW_TO_FRAME_PIXEL_X (w, gx);
-		}
+	      rect->y = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
-	  }
+	      return 1;
-}
+	    }
+	  break;
-return found;
+	}
+}
+return 0;
 }
 /* Return the current position of the mouse.
 *FP should be a frame which indicates which display to ask about.
 to help debug the loss-of-chars-during-GC problem.  */
 static int temp_index;
 static short temp_buffer[100];
+#define STORE_KEYSYM_FOR_DEBUG(keysym)				\
+if (temp_index == sizeof temp_buffer / sizeof (short))	\
+temp_index = 0;						\
+temp_buffer[temp_index++] = (keysym)
 /* Set this to nonzero to fake an "X I/O error"
 on a particular display.  */
 struct x_display_info *XTread_socket_fake_io_error;
 {								\
 	 if (f->output_data.x->saved_menu_event == 0)			\
 f->output_data.x->saved_menu_event				\
 	     = (XEvent *) xmalloc (sizeof (XEvent));			\
 bcopy (&event, f->output_data.x->saved_menu_event, size);	\
-if (numchars >= 1)						\
+	 inev.kind = MENU_BAR_ACTIVATE_EVENT;				\
-{								\
+	 XSETFRAME (inev.frame_or_window, f);				\
-bufp->kind = MENU_BAR_ACTIVATE_EVENT;			\
-XSETFRAME (bufp->frame_or_window, f);			\
-bufp->arg = Qnil;						\
-bufp++;							\
-count++;							\
-numchars--;						\
-}								\
 }								\
 while (0)
 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
 #define SET_SAVED_KEY_EVENT    SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
 return XFilterEvent (event, f1 ? FRAME_X_WINDOW (f1) : None);
 }
 #endif
 #ifdef USE_GTK
-static struct input_event **current_bufp;
-static int *current_numcharsp;
 static int current_count;
 static int current_finish;
+static struct input_event *current_hold_quit;
 /* This is the filter function invoked by the GTK event loop.
 It is invoked before the XEvent is translated to a GdkEvent,
-so we have a chanse to act on the event before GTK. */
+so we have a chance to act on the event before GTK. */
 static GdkFilterReturn
 event_handler_gdk (gxev, ev, data)
 GdkXEvent *gxev;
 GdkEvent *ev;
 gpointer data;
 {
 XEvent *xev = (XEvent *) gxev;
-if (current_numcharsp)
+if (current_count >= 0)
 {
 struct x_display_info *dpyinfo;
 dpyinfo = x_display_info_for_display (xev->xany.display);
 #endif
 if (! dpyinfo)
 current_finish = X_EVENT_NORMAL;
 else
-current_count += handle_one_xevent (dpyinfo,
+	{
-xev,
+	  current_count +=
-current_bufp,
+	    handle_one_xevent (dpyinfo, xev, &current_finish,
-current_numcharsp,
+			       current_hold_quit);
-&current_finish);
+	}
 }
 else
 current_finish = x_dispatch_event (xev, xev->xany.display);
 if (current_finish == X_EVENT_GOTO_OUT || current_finish == X_EVENT_DROP)
 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
 *FINISH is zero if caller should continue reading events.
 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
-Events representing keys are stored in buffer *BUFP_R,
-which can hold up to *NUMCHARSP characters.
 We return the number of characters stored into the buffer. */
 static int
-handle_one_xevent (dpyinfo, eventp, bufp_r, numcharsp, finish)
+handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
 struct x_display_info *dpyinfo;
 XEvent *eventp;
-/* register */ struct input_event **bufp_r;
-/* register */ int *numcharsp;
 int *finish;
-{
+struct input_event *hold_quit;
+{
+struct input_event inev;
 int count = 0;
+int do_help = 0;
 int nbytes = 0;
 struct frame *f;
 struct coding_system coding;
-struct input_event *bufp = *bufp_r;
-int numchars = *numcharsp;
 XEvent event = *eventp;
 *finish = X_EVENT_NORMAL;
+EVENT_INIT (inev);
+inev.kind = NO_EVENT;
+inev.arg = Qnil;
 switch (event.type)
 {
 case ClientMessage:
 {
 XSync (d, False);
 x_uncatch_errors (d, count);
 }
 /* Not certain about handling scroll bars here */
 #endif /* 0 */
+		goto done;
 }
-else if (event.xclient.data.l[0]
+if (event.xclient.data.l[0]
 == dpyinfo->Xatom_wm_save_yourself)
 {
 /* Save state modify the WM_COMMAND property to
 something which can reinstate us.  This notifies
 the session manager, who's looking for such a
 PropertyNotify.  Can restart processing when
 a keyboard or mouse event arrives.  */
 /* If we have a session manager, don't set this.
 KDE will then start two Emacsen, one for the
 session manager and one for this. */
-if (numchars > 0
 #ifdef HAVE_X_SM
-&& ! x_session_have_connection ()
+if (! x_session_have_connection ())
 #endif
-)
 {
 f = x_top_window_to_frame (dpyinfo,
 event.xclient.window);
 /* This is just so we only give real data once
 for a single Emacs process.  */
 else if (f)
 XSetCommand (FRAME_X_DISPLAY (f),
 event.xclient.window,
 0, 0);
 }
+		goto done;
 }
-else if (event.xclient.data.l[0]
-== dpyinfo->Xatom_wm_delete_window)
+if (event.xclient.data.l[0]
+		== dpyinfo->Xatom_wm_delete_window)
 {
-struct frame *f
+f = x_any_window_to_frame (dpyinfo,
-= x_any_window_to_frame (dpyinfo,
 event.xclient.window);
+if (!f)
-if (f)
+		  goto OTHER; /* May be a dialog that is to be removed  */
-{
-if (numchars == 0)
+		inev.kind = DELETE_WINDOW_EVENT;
-abort ();
+		XSETFRAME (inev.frame_or_window, f);
+		goto done;
-bufp->kind = DELETE_WINDOW_EVENT;
-XSETFRAME (bufp->frame_or_window, f);
-bufp->arg = Qnil;
-bufp++;
-count += 1;
-numchars -= 1;
-}
-else
-goto OTHER; /* May be a dialog that is to be removed  */
 }
+	    goto done;
 }
-else if (event.xclient.message_type
+if (event.xclient.message_type
 == dpyinfo->Xatom_wm_configure_denied)
 {
+	    goto done;
 }
-else if (event.xclient.message_type
-== dpyinfo->Xatom_wm_window_moved)
+if (event.xclient.message_type
+	    == dpyinfo->Xatom_wm_window_moved)
 {
 int new_x, new_y;
-struct frame *f
+	    f = x_window_to_frame (dpyinfo, event.xclient.window);
-= x_window_to_frame (dpyinfo, event.xclient.window);
 new_x = event.xclient.data.s[0];
 new_y = event.xclient.data.s[1];
 if (f)
 {
 f->left_pos = new_x;
 f->top_pos = new_y;
 }
+	    goto done;
 }
 #ifdef HACK_EDITRES
-else if (event.xclient.message_type
+if (event.xclient.message_type
-== dpyinfo->Xatom_editres)
+	    == dpyinfo->Xatom_editres)
 {
-struct frame *f
+	    f = x_any_window_to_frame (dpyinfo, event.xclient.window);
-= x_any_window_to_frame (dpyinfo, event.xclient.window);
 _XEditResCheckMessages (f->output_data.x->widget, NULL,
 &event, NULL);
+	    goto done;
 }
 #endif /* HACK_EDITRES */
-else if ((event.xclient.message_type
-== dpyinfo->Xatom_DONE)
+if ((event.xclient.message_type
-|| (event.xclient.message_type
+	     == dpyinfo->Xatom_DONE)
-== dpyinfo->Xatom_PAGE))
+	    || (event.xclient.message_type
+		== dpyinfo->Xatom_PAGE))
 {
 /* Ghostview job completed.  Kill it.  We could
 reply with "Next" if we received "Page", but we
 currently never do because we are interested in
 images, only, which should have 1 page.  */
 Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
-struct frame *f
+	    f = x_window_to_frame (dpyinfo, event.xclient.window);
-= x_window_to_frame (dpyinfo, event.xclient.window);
 x_kill_gs_process (pixmap, f);
 expose_frame (f, 0, 0, 0, 0);
+	    goto done;
 }
 #ifdef USE_TOOLKIT_SCROLL_BARS
 /* Scroll bar callbacks send a ClientMessage from which
 we construct an input_event.  */
-else if (event.xclient.message_type
+if (event.xclient.message_type
-== dpyinfo->Xatom_Scrollbar)
+	    == dpyinfo->Xatom_Scrollbar)
 {
-x_scroll_bar_to_input_event (&event, bufp);
+x_scroll_bar_to_input_event (&event, &inev);
-++bufp, ++count, --numchars;
+	    *finish = X_EVENT_GOTO_OUT;
-goto out;
+goto done;
 }
 #endif /* USE_TOOLKIT_SCROLL_BARS */
-else
-{
+	f = x_any_window_to_frame (dpyinfo, event.xclient.window);
-struct frame *f
-= x_any_window_to_frame (dpyinfo, event.xclient.window);
+	if (!f)
+	  goto OTHER;
-if (f)
-{
+	if (x_handle_dnd_message (f, &event.xclient, dpyinfo, &inev))
-int ret = x_handle_dnd_message (f, &event.xclient,
+	  *finish = X_EVENT_DROP;
-dpyinfo, bufp);
-if (ret > 0)
-{
-++bufp, ++count, --numchars;
-}
-if (ret != 0)
-*finish = X_EVENT_DROP;
-}
-else
-goto OTHER;
-}
 }
 break;
 case SelectionNotify:
 #ifdef USE_X_TOOLKIT
 goto OTHER;
 #endif /* USE_X_TOOLKIT */
 {
 XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
-if (numchars == 0)
+inev.kind = SELECTION_CLEAR_EVENT;
-abort ();
+SELECTION_EVENT_DISPLAY (&inev) = eventp->display;
+SELECTION_EVENT_SELECTION (&inev) = eventp->selection;
-bufp->kind = SELECTION_CLEAR_EVENT;
+SELECTION_EVENT_TIME (&inev) = eventp->time;
-SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+inev.frame_or_window = Qnil;
-SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
-SELECTION_EVENT_TIME (bufp) = eventp->time;
-bufp->frame_or_window = Qnil;
-bufp->arg = Qnil;
-bufp++;
-count += 1;
-numchars -= 1;
 }
 break;
 case SelectionRequest:	/* Someone wants our selection.  */
 #ifdef USE_X_TOOLKIT
 else
 {
 XSelectionRequestEvent *eventp
 = (XSelectionRequestEvent *) &event;
-if (numchars == 0)
+inev.kind = SELECTION_REQUEST_EVENT;
-abort ();
+SELECTION_EVENT_DISPLAY (&inev) = eventp->display;
+SELECTION_EVENT_REQUESTOR (&inev) = eventp->requestor;
-bufp->kind = SELECTION_REQUEST_EVENT;
+SELECTION_EVENT_SELECTION (&inev) = eventp->selection;
-SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+SELECTION_EVENT_TARGET (&inev) = eventp->target;
-SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
+SELECTION_EVENT_PROPERTY (&inev) = eventp->property;
-SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
+SELECTION_EVENT_TIME (&inev) = eventp->time;
-SELECTION_EVENT_TARGET (bufp) = eventp->target;
+inev.frame_or_window = Qnil;
-SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
-SELECTION_EVENT_TIME (bufp) = eventp->time;
-bufp->frame_or_window = Qnil;
-bufp->arg = Qnil;
-bufp++;
-count += 1;
-numchars -= 1;
 }
 break;
 case PropertyNotify:
 #if 0 /* This is plain wrong.  In the case that we are waiting for a
 /* Perhaps reparented due to a WM restart.  Reset this.  */
 FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_UNKNOWN;
 }
 goto OTHER;
-break;
 case Expose:
 f = x_window_to_frame (dpyinfo, event.xexpose.window);
 if (f)
 {
 and that way, we know the window is not iconified now.  */
 if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
 {
 f->async_iconified = 1;
-bufp->kind = ICONIFY_EVENT;
+inev.kind = ICONIFY_EVENT;
-XSETFRAME (bufp->frame_or_window, f);
+XSETFRAME (inev.frame_or_window, f);
-bufp->arg = Qnil;
-bufp++;
-count++;
-numchars--;
 }
 }
 goto OTHER;
 case MapNotify:
 f->async_iconified = 0;
 f->output_data.x->has_been_visible = 1;
 if (f->iconified)
 {
-bufp->kind = DEICONIFY_EVENT;
+inev.kind = DEICONIFY_EVENT;
-XSETFRAME (bufp->frame_or_window, f);
+XSETFRAME (inev.frame_or_window, f);
-bufp->arg = Qnil;
-bufp++;
-count++;
-numchars--;
 }
 else if (! NILP (Vframe_list)
 && ! NILP (XCDR (Vframe_list)))
 /* Force a redisplay sooner or later
 to update the frame titles
 unsigned char copy_buffer[513];
 unsigned char *copy_bufptr = copy_buffer;
 int copy_bufsiz = sizeof (copy_buffer);
 int modifiers;
 Lisp_Object coding_system = Qlatin_1;
+	  Lisp_Object c;
 event.xkey.state
 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
 extra_keyboard_modifiers);
 modifiers = event.xkey.state;
 if (compose_status.chars_matched > 0 && nbytes == 0)
 break;
 orig_keysym = keysym;
-if (numchars > 1)
+	  /* Common for all keysym input events.  */
-{
+	  XSETFRAME (inev.frame_or_window, f);
-Lisp_Object c;
+	  inev.modifiers
+	    = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f), modifiers);
-/* First deal with keysyms which have defined
+	  inev.timestamp = event.xkey.time;
-translations to characters.  */
-if (keysym >= 32 && keysym < 128)
+	  /* First deal with keysyms which have defined
-/* Avoid explicitly decoding each ASCII character.  */
+	     translations to characters.  */
-{
+	  if (keysym >= 32 && keysym < 128)
-bufp->kind = ASCII_KEYSTROKE_EVENT;
+	    /* Avoid explicitly decoding each ASCII character.  */
-bufp->code = keysym;
+	    {
-XSETFRAME (bufp->frame_or_window, f);
+	      inev.kind = ASCII_KEYSTROKE_EVENT;
-bufp->arg = Qnil;
+	      inev.code = keysym;
-bufp->modifiers
+	      goto done_keysym;
-= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+	    }
-modifiers);
-bufp->timestamp = event.xkey.time;
+	  /* Now non-ASCII.  */
-bufp++;
+	  if (HASH_TABLE_P (Vx_keysym_table)
-count++;
+	      && (NATNUMP (c = Fgethash (make_number (keysym),
-numchars--;
+					 Vx_keysym_table,
-}
+					 Qnil))))
-/* Now non-ASCII.  */
+	    {
-else if (HASH_TABLE_P (Vx_keysym_table)
+	      inev.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
-&& (NATNUMP (c = Fgethash (make_number (keysym),
+			    ? ASCII_KEYSTROKE_EVENT
-Vx_keysym_table,
+			    : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
-Qnil))))
+	      inev.code = XFASTINT (c);
-{
+	      goto done_keysym;
-bufp->kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
+	    }
-? ASCII_KEYSTROKE_EVENT
-: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
+	  /* Random non-modifier sorts of keysyms.  */
-bufp->code = XFASTINT (c);
+	  if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
-XSETFRAME (bufp->frame_or_window, f);
-bufp->arg = Qnil;
-bufp->modifiers
-= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
-modifiers);
-bufp->timestamp = event.xkey.time;
-bufp++;
-count++;
-numchars--;
-}
-/* Random non-modifier sorts of keysyms.  */
-else if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
 || keysym == XK_Delete
 #ifdef XK_ISO_Left_Tab
 || (keysym >= XK_ISO_Left_Tab
 && keysym <= XK_ISO_Enter)
 #endif
 >=  XK_ISO_Lock
 && (unsigned)(orig_keysym)
 <= XK_ISO_Last_Group_Lock)
 #endif
 ))
-{
+	    {
-if (temp_index == sizeof temp_buffer / sizeof (short))
+	      STORE_KEYSYM_FOR_DEBUG (keysym);
-temp_index = 0;
+	      /* make_lispy_event will convert this to a symbolic
-temp_buffer[temp_index++] = keysym;
+		 key.  */
-/* make_lispy_event will convert this to a symbolic
+	      inev.kind = NON_ASCII_KEYSTROKE_EVENT;
-key.  */
+	      inev.code = keysym;
-bufp->kind = NON_ASCII_KEYSTROKE_EVENT;
+	      goto done_keysym;
-bufp->code = keysym;
+	    }
-XSETFRAME (bufp->frame_or_window, f);
-bufp->arg = Qnil;
+	  {	/* Raw bytes, not keysym.  */
-bufp->modifiers
+	    register int i;
-= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
+	    register int c;
-modifiers);
+	    int nchars, len;
-bufp->timestamp = event.xkey.time;
-bufp++;
+	    /* The input should be decoded with `coding_system'
-count++;
+	       which depends on which X*LookupString function
-numchars--;
+	       we used just above and the locale.  */
-}
+	    setup_coding_system (coding_system, &coding);
-else if (numchars > nbytes)
+	    coding.src_multibyte = 0;
-{	/* Raw bytes, not keysym.  */
+	    coding.dst_multibyte = 1;
-register int i;
+	    /* The input is converted to events, thus we can't
-register int c;
+	       handle composition.  Anyway, there's no XIM that
-int nchars, len;
+	       gives us composition information.  */
+	    coding.composing = COMPOSITION_DISABLED;
-/* The input should be decoded with `coding_system'
-which depends on which X*LookupString function
+	    for (i = 0; i < nbytes; i++)
-we used just above and the locale.  */
+	      {
-setup_coding_system (coding_system, &coding);
+		STORE_KEYSYM_FOR_DEBUG (copy_bufptr[i]);
-coding.src_multibyte = 0;
+	      }
-coding.dst_multibyte = 1;
-/* The input is converted to events, thus we can't
+	    {
-handle composition.  Anyway, there's no XIM that
+	      /* Decode the input data.  */
-gives us composition information.  */
+	      int require;
-coding.composing = COMPOSITION_DISABLED;
+	      unsigned char *p;
-for (i = 0; i < nbytes; i++)
+	      require = decoding_buffer_size (&coding, nbytes);
-{
+	      p = (unsigned char *) alloca (require);
-if (temp_index == (sizeof temp_buffer
+	      coding.mode |= CODING_MODE_LAST_BLOCK;
-/ sizeof (short)))
+	      /* We explicitly disable composition handling because
-temp_index = 0;
+		 key data should not contain any composition sequence.  */
-temp_buffer[temp_index++] = copy_bufptr[i];
+	      coding.composing = COMPOSITION_DISABLED;
-}
+	      decode_coding (&coding, copy_bufptr, p, nbytes, require);
+	      nbytes = coding.produced;
-{
+	      nchars = coding.produced_char;
-/* Decode the input data.  */
+	      copy_bufptr = p;
-int require;
+	    }
-unsigned char *p;
+	    /* Convert the input data to a sequence of
-require = decoding_buffer_size (&coding, nbytes);
+	       character events.  */
-p = (unsigned char *) alloca (require);
+	    for (i = 0; i < nbytes; i += len)
-coding.mode |= CODING_MODE_LAST_BLOCK;
+	      {
-/* We explicitly disable composition
+		if (nchars == nbytes)
-handling because key data should
+		  c = copy_bufptr[i], len = 1;
-not contain any composition
+		else
-sequence.  */
+		  c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
-coding.composing = COMPOSITION_DISABLED;
+					      nbytes - i, len);
-decode_coding (&coding, copy_bufptr, p,
+		inev.kind = (SINGLE_BYTE_CHAR_P (c)
-nbytes, require);
+			      ? ASCII_KEYSTROKE_EVENT
-nbytes = coding.produced;
+			      : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
-nchars = coding.produced_char;
+		inev.code = c;
-copy_bufptr = p;
+		kbd_buffer_store_event_hold (&inev, hold_quit);
-}
+	      }
-/* Convert the input data to a sequence of
+	    /* Previous code updated count by nchars rather than nbytes,
-character events.  */
+	       but that seems bogus to me.  ++kfs  */
-for (i = 0; i < nbytes; i += len)
+	    count += nbytes;
-{
-if (nchars == nbytes)
+	    inev.kind = NO_EVENT;  /* Already stored above.  */
-c = copy_bufptr[i], len = 1;
-else
+	    if (keysym == NoSymbol)
-c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
+	      break;
-nbytes - i, len);
+	  }
-bufp->kind = (SINGLE_BYTE_CHAR_P (c)
-? ASCII_KEYSTROKE_EVENT
-: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
-bufp->code = c;
-XSETFRAME (bufp->frame_or_window, f);
-bufp->arg = Qnil;
-bufp->modifiers
-= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
-modifiers);
-bufp->timestamp = event.xkey.time;
-bufp++;
-}
-count += nchars;
-numchars -= nchars;
-if (keysym == NoSymbol)
-break;
-}
-else
-abort ();
-}
-else
-abort ();
 }
+done_keysym:
 #ifdef HAVE_X_I18N
 /* Don't dispatch this event since XtDispatchEvent calls
 XFilterEvent, and two calls in a row may freeze the
 client.  */
 break;
 #else
 goto OTHER;
 #endif
 case EnterNotify:
-{
+x_detect_focus_change (dpyinfo, &event, &inev);
-int n;
+f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
-n = x_detect_focus_change (dpyinfo, &event, bufp, numchars);
-if (n > 0)
-{
-bufp += n, count += n, numchars -= n;
-}
-f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
 #if 0
 if (event.xcrossing.focus)
-{
+	{
-/* Avoid nasty pop/raise loops.  */
+	  /* Avoid nasty pop/raise loops.  */
-if (f && (!(f->auto_raise)
+	  if (f && (!(f->auto_raise)
-|| !(f->auto_lower)
+		    || !(f->auto_lower)
-|| (event.xcrossing.time - enter_timestamp) > 500))
+		    || (event.xcrossing.time - enter_timestamp) > 500))
-{
+	    {
-x_new_focus_frame (dpyinfo, f);
+	      x_new_focus_frame (dpyinfo, f);
-enter_timestamp = event.xcrossing.time;
+	      enter_timestamp = event.xcrossing.time;
-}
+	    }
-}
+	}
 else if (f == dpyinfo->x_focus_frame)
-x_new_focus_frame (dpyinfo, 0);
+	x_new_focus_frame (dpyinfo, 0);
 #endif
 /* EnterNotify counts as mouse movement,
-so update things that depend on mouse position.  */
+	 so update things that depend on mouse position.  */
 if (f && !f->output_data.x->hourglass_p)
-note_mouse_movement (f, &event.xmotion);
+	note_mouse_movement (f, &event.xmotion);
 goto OTHER;
-}
 case FocusIn:
-{
+x_detect_focus_change (dpyinfo, &event, &inev);
-int n;
-n = x_detect_focus_change (dpyinfo, &event, bufp, numchars);
-if (n > 0)
-{
-bufp += n, count += n, numchars -= n;
-}
-}
 goto OTHER;
 case LeaveNotify:
-{
+x_detect_focus_change (dpyinfo, &event, &inev);
-int n;
-n = x_detect_focus_change (dpyinfo, &event, bufp, numchars);
-if (n > 0)
-{
-bufp += n, count += n, numchars -= n;
-}
-}
 f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
 if (f)
 {
 if (f == dpyinfo->mouse_face_mouse_frame)
 /* Generate a nil HELP_EVENT to cancel a help-echo.
 Do it only if there's something to cancel.
 Otherwise, the startup message is cleared when
 the mouse leaves the frame.  */
 if (any_help_event_p)
-{
+	    do_help = -1;
-Lisp_Object frame;
-int n;
-XSETFRAME (frame, f);
-help_echo_string = Qnil;
-n = gen_help_event (bufp, numchars,
-Qnil, frame, Qnil, Qnil, 0);
-bufp += n, count += n, numchars -= n;
-}
 }
 goto OTHER;
 case FocusOut:
-{
+x_detect_focus_change (dpyinfo, &event, &inev);
-int n;
-n = x_detect_focus_change (dpyinfo, &event, bufp, numchars);
-if (n > 0)
-{
-bufp += n, count += n, numchars -= n;
-}
-}
 goto OTHER;
 case MotionNotify:
 {
 previous_help_echo_string = help_echo_string;
 /* Window will be selected only when it is not selected now and
 last mouse movement event was not in it.  Minibuffer window
 will be selected iff it is active.  */
 if (WINDOWP (window)
 && !EQ (window, last_window)
-&& !EQ (window, selected_window)
+&& !EQ (window, selected_window))
-&& numchars > 0)
 {
-bufp->kind = SELECT_WINDOW_EVENT;
+inev.kind = SELECT_WINDOW_EVENT;
-bufp->frame_or_window = window;
+inev.frame_or_window = window;
-bufp->arg = Qnil;
-++bufp, ++count, --numchars;
 }
 last_window=window;
 }
 note_mouse_movement (f, &event.xmotion);
 /* If the contents of the global variable help_echo_string
 has changed, generate a HELP_EVENT.  */
 if (!NILP (help_echo_string)
 || !NILP (previous_help_echo_string))
-{
+	  do_help = 1;
-Lisp_Object frame;
-int n;
-if (f)
-XSETFRAME (frame, f);
-else
-frame = Qnil;
-any_help_event_p = 1;
-n = gen_help_event (bufp, numchars, help_echo_string, frame,
-help_echo_window, help_echo_object,
-help_echo_pos);
-bufp += n, count += n, numchars -= n;
-}
 goto OTHER;
 }
 case ConfigureNotify:
 f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
 case ButtonRelease:
 case ButtonPress:
 {
 /* If we decide we want to generate an event to be seen
 by the rest of Emacs, we put it here.  */
-struct input_event emacs_event;
 int tool_bar_p = 0;
-emacs_event.kind = NO_EVENT;
 bzero (&compose_status, sizeof (compose_status));
 if (dpyinfo->grabbed
 && last_mouse_frame
 && FRAME_LIVE_P (last_mouse_frame))
 || f == dpyinfo->x_focus_frame)
 {
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 if (! popup_activated ())
 #endif
-construct_mouse_click (&emacs_event, &event, f);
+construct_mouse_click (&inev, &event, f);
 }
 }
 else
 {
 struct scroll_bar *bar
 #ifdef USE_TOOLKIT_SCROLL_BARS
 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
 scroll bars.  */
 if (bar && event.xbutton.state & ControlMask)
 {
-x_scroll_bar_handle_click (bar, &event, &emacs_event);
+x_scroll_bar_handle_click (bar, &event, &inev);
 *finish = X_EVENT_DROP;
 }
 #else /* not USE_TOOLKIT_SCROLL_BARS */
 if (bar)
-x_scroll_bar_handle_click (bar, &event, &emacs_event);
+x_scroll_bar_handle_click (bar, &event, &inev);
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 }
 if (event.type == ButtonPress)
 {
 if (!tool_bar_p)
 last_tool_bar_item = -1;
 }
 else
 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
-if (numchars >= 1 && emacs_event.kind != NO_EVENT)
-{
-bcopy (&emacs_event, bufp, sizeof (struct input_event));
-bufp++;
-count++;
-numchars--;
-}
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
 /* For a down-event in the menu bar,
 don't pass it to Xt right now.
 UNBLOCK_INPUT;
 #endif /* USE_X_TOOLKIT */
 break;
 }
-goto ret;
+done:
+if (inev.kind != NO_EVENT)
-out:
+{
-*finish = X_EVENT_GOTO_OUT;
+kbd_buffer_store_event_hold (&inev, hold_quit);
+count++;
-ret:
+}
-*bufp_r = bufp;
-*numcharsp = numchars;
+if (do_help
+&& !(hold_quit && hold_quit->kind != NO_EVENT))
+{
+Lisp_Object frame;
+if (f)
+	XSETFRAME (frame, f);
+else
+	frame = Qnil;
+if (do_help > 0)
+	{
+	  any_help_event_p = 1;
+	  gen_help_event (help_echo_string, frame, help_echo_window,
+			  help_echo_object, help_echo_pos);
+	}
+else
+	{
+	  help_echo_string = Qnil;
+	  gen_help_event (Qnil, frame, Qnil, Qnil, 0);
+	}
+count++;
+}
 *eventp = event;
 return count;
 }
 /* Handles the XEvent EVENT on display DISPLAY.
 x_dispatch_event (event, display)
 XEvent *event;
 Display *display;
 {
 struct x_display_info *dpyinfo;
-struct input_event bufp[10];
-struct input_event *bufpp;
-int numchars = 10;
 int finish = X_EVENT_NORMAL;
-for (bufpp = bufp; bufpp != bufp + 10; bufpp++)
-EVENT_INIT (*bufpp);
-bufpp = bufp;
 dpyinfo = x_display_info_for_display (display);
 if (dpyinfo)
-{
+handle_one_xevent (dpyinfo, event, &finish, 0);
-int i, events;
-events = handle_one_xevent (dpyinfo,
-event,
-&bufpp,
-&numchars,
-&finish);
-for (i = 0; i < events; ++i)
-kbd_buffer_store_event (&bufp[i]);
-}
 return finish;
 }
 /* Read events coming from the X server.
 This routine is called by the SIGIO handler.
 We return as soon as there are no more events to be read.
-Events representing keys are stored in buffer BUFP,
-which can hold up to NUMCHARS characters.
 We return the number of characters stored into the buffer,
 thus pretending to be `read'.
 EXPECTED is nonzero if the caller knows input is available.  */
 static int
-XTread_socket (sd, bufp, numchars, expected)
+XTread_socket (sd, expected, hold_quit)
 register int sd;
-/* register */ struct input_event *bufp;
-/* register */ int numchars;
 int expected;
+struct input_event *hold_quit;
 {
 int count = 0;
 XEvent event;
 int event_found = 0;
 struct x_display_info *dpyinfo;
 interrupt_input_pending = 0;
 BLOCK_INPUT;
 /* So people can tell when we have read the available input.  */
 input_signal_count++;
-if (numchars <= 0)
-abort ();			/* Don't think this happens.  */
 ++handling_signal;
 /* Find the display we are supposed to read input for.
 It's the one communicating on descriptor SD.  */
 	  XTread_socket_fake_io_error = 0;
 	  x_io_error_quitter (dpyinfo->display);
 	}
 #ifdef HAVE_X_SM
-BLOCK_INPUT;
+{
-count += x_session_check_input (bufp, &numchars);
+	struct input_event inev;
-UNBLOCK_INPUT;
+	BLOCK_INPUT;
+	/* We don't need to EVENT_INIT (inev) here, as
+	   x_session_check_input copies an entire input_event.  */
+	if (x_session_check_input (&inev))
+	  {
+	    kbd_buffer_store_event_hold (&inev, hold_quit);
+	    count++;
+	  }
+	UNBLOCK_INPUT;
+}
 #endif
 #ifndef USE_GTK
 while (XPending (dpyinfo->display))
 	{
 if (x_filter_event (dpyinfo, &event))
 break;
 #endif
 	  event_found = 1;
-count += handle_one_xevent (dpyinfo,
+count += handle_one_xevent (dpyinfo, &event, &finish, hold_quit);
-&event,
-&bufp,
-&numchars,
-&finish);
 if (finish == X_EVENT_GOTO_OUT)
 goto out;
 }
 #endif /* not USE_GTK */
 from all displays.  */
 while (gtk_events_pending ())
 {
 current_count = count;
-current_numcharsp = &numchars;
+current_hold_quit = hold_quit;
-current_bufp = &bufp;
 gtk_main_iteration ();
 count = current_count;
-current_bufp = 0;
+current_count = -1;
-current_numcharsp = 0;
+current_hold_quit = 0;
 if (current_finish == X_EVENT_GOTO_OUT)
 break;
 }
 #endif /* USE_GTK */
 {
 x_raise_frame (pending_autoraise_frame);
 pending_autoraise_frame = 0;
 }
+--handling_signal;
 UNBLOCK_INPUT;
---handling_signal;
 return count;
 }
 x_noop_count = 0;
 last_tool_bar_item = -1;
 any_help_event_p = 0;
+#ifdef USE_GTK
+current_count = -1;
+#endif
 /* Try to use interrupt input; if we can't, then start polling.  */
 Fset_input_mode (Qt, Qnil, Qt, Qnil);
 #ifdef USE_X_TOOLKIT
 XtToolkitInitialize ();

Mercurial > emacs

comparison src/xterm.c @ 54173:03cb01738926