xemacs-beta: src/event-stream.c comparison

comparison src/event-stream.c @ 440:8de8e3f6228a r21-2-28

Import from CVS: tag r21-2-28

author	cvs
date	Mon, 13 Aug 2007 11:33:38 +0200
parents	9d177e8d4150
children	abe6d1db359e

comparison

equal deleted inserted replaced

-:357dd071b03c
+:8de8e3f6228a
 {
 return event_stream && event_stream->event_pending_p (user);
 }
 static int
-maybe_read_quit_event (struct Lisp_Event *event)
+maybe_read_quit_event (Lisp_Event *event)
 {
 /* A C-g that came from `sigint_happened' will always come from the
 controlling terminal.  If that doesn't exist, however, then the
 user manually sent us a SIGINT, and we pretend the C-g came from
 the selected console. */
 }
 return 0;
 }
 void
-event_stream_next_event (struct Lisp_Event *event)
+event_stream_next_event (Lisp_Event *event)
 {
 Lisp_Object event_obj;
 check_event_stream_ok (EVENT_STREAM_READ);
 #endif
 maybe_kbd_translate (event_obj);
 }
 void
-event_stream_handle_magic_event (struct Lisp_Event *event)
+event_stream_handle_magic_event (Lisp_Event *event)
 {
 check_event_stream_ok (EVENT_STREAM_READ);
 event_stream->handle_magic_event_cb (event);
 }
 con->input_enabled = 0;
 }
 }
 void
-event_stream_select_process (struct Lisp_Process *proc)
+event_stream_select_process (Lisp_Process *proc)
 {
 check_event_stream_ok (EVENT_STREAM_PROCESS);
 if (!get_process_selected_p (proc))
 {
 event_stream->select_process_cb (proc);
 set_process_selected_p (proc, 1);
 }
 }
 void
-event_stream_unselect_process (struct Lisp_Process *proc)
+event_stream_unselect_process (Lisp_Process *proc)
 {
 check_event_stream_ok (EVENT_STREAM_PROCESS);
 if (get_process_selected_p (proc))
 {
 event_stream->unselect_process_cb (proc);
 	  XEVENT (event)->event.key.modifiers = 0;
 	  did_translate = 1;
 	}
 else if (CHARP (traduit))
 	{
-	  struct Lisp_Event ev2;
+	  Lisp_Event ev2;
 	  /* This used to call Fcharacter_to_event() directly into EVENT,
 	     but that can eradicate timestamps and other such stuff.
 	     This way is safer. */
 	  zero_event (&ev2);
 static Lisp_Object Vtimeout_free_list;
 static Lisp_Object
 mark_timeout (Lisp_Object obj)
 {
-struct Lisp_Timeout *tm = XTIMEOUT (obj);
+Lisp_Timeout *tm = XTIMEOUT (obj);
 mark_object (tm->function);
 return tm->object;
 }
 /* Should never, ever be called. (except by an external debugger) */
 static void
 print_timeout (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-CONST struct Lisp_Timeout *t = XTIMEOUT (obj);
+CONST Lisp_Timeout *t = XTIMEOUT (obj);
 char buf[64];
 sprintf (buf, "#<INTERNAL OBJECT (XEmacs bug?) (timeout) 0x%lx>",
 	   (unsigned long) t);
 write_c_string (buf, printcharfun);
 }
 static const struct lrecord_description timeout_description[] = {
-{ XD_LISP_OBJECT, offsetof(struct Lisp_Timeout, function), 2 },
+{ XD_LISP_OBJECT, offsetof (Lisp_Timeout, function) },
+{ XD_LISP_OBJECT, offsetof (Lisp_Timeout, object) },
 { XD_END }
 };
 DEFINE_LRECORD_IMPLEMENTATION ("timeout", timeout,
 			       mark_timeout, print_timeout,
-			       0, 0, 0, timeout_description, struct Lisp_Timeout);
+			       0, 0, 0, timeout_description, Lisp_Timeout);
 /* Generate a timeout and return its ID. */
 int
 event_stream_generate_wakeup (unsigned int milliseconds,
 			      unsigned int vanilliseconds,
 			      Lisp_Object function, Lisp_Object object,
 			      int async_p)
 {
 Lisp_Object op = allocate_managed_lcrecord (Vtimeout_free_list);
-struct Lisp_Timeout *timeout = XTIMEOUT (op);
+Lisp_Timeout *timeout = XTIMEOUT (op);
 EMACS_TIME current_time;
 EMACS_TIME interval;
 timeout->id = timeout_id_tick++;
 timeout->resignal_msecs = vanilliseconds;
 static int
 event_stream_resignal_wakeup (int interval_id, int async_p,
 			      Lisp_Object *function, Lisp_Object *object)
 {
 Lisp_Object op = Qnil, rest;
-struct Lisp_Timeout *timeout;
+Lisp_Timeout *timeout;
 Lisp_Object *timeout_list;
 struct gcpro gcpro1;
 int id;
 GCPRO1 (op); /* just in case ...  because it's removed from the list
 }
 void
 event_stream_disable_wakeup (int id, int async_p)
 {
-struct Lisp_Timeout *timeout = 0;
+Lisp_Timeout *timeout = 0;
 Lisp_Object rest;
 Lisp_Object *timeout_list;
 if (async_p)
 timeout_list = &pending_async_timeout_list;
 }
 static int
 event_stream_wakeup_pending_p (int id, int async_p)
 {
-struct Lisp_Timeout *timeout;
+Lisp_Timeout *timeout;
 Lisp_Object rest;
 Lisp_Object timeout_list;
 int found = 0;
 Fdeallocate_event (event);
 DEBUG_PRINT_EMACS_EVENT ("command event queue", target_event);
 }
 else
 {
-struct Lisp_Event *e = XEVENT (target_event);
+Lisp_Event *e = XEVENT (target_event);
 /* The command_event_queue was empty.  Wait for an event. */
 event_stream_next_event (e);
 /* If this was a timeout, then we need to extract some data
 	 out of the returned closure and might need to resignal
 	return;
 }
 case timeout_event:
 {
-	struct Lisp_Event *e = XEVENT (event);
+	Lisp_Event *e = XEVENT (event);
 	if (!NILP (e->event.timeout.function))
 	  call1 (e->event.timeout.function,
 		 e->event.timeout.object);
 	return;
 }
 Emchar c = 0;
 if ((key->modifiers & MOD_SHIFT)
 || (CHAR_OR_CHAR_INTP (key->keysym)
 && ((c = XCHAR_OR_CHAR_INT (key->keysym)), c >= 'A' && c <= 'Z')))
 {
-struct Lisp_Event terminal_copy = *XEVENT (terminal);
+Lisp_Event terminal_copy = *XEVENT (terminal);
 if (key->modifiers & MOD_SHIFT)
 key->modifiers &= (~ MOD_SHIFT);
 else
 key->keysym = make_char (c + 'a' - 'A');
 Lisp_Object recent = command_builder->most_current_event;
 if (EVENTP (recent)
 	&& event_matches_key_specifier_p (XEVENT (recent), Vmeta_prefix_char))
 {
-	struct Lisp_Event *e;
+	Lisp_Event *e;
 	/* When we see a sequence like "ESC x", pretend we really saw "M-x".
 	   DoubleThink the recent-keys and this-command-keys as well. */
 	/* Modify the previous most-recently-pushed event on the command
 	   builder to be a copy of this one with the meta-bit set instead of
 	    else
 	      maybe_echo_keys (command_builder, 0);
 	  }
 	else if (!NILP (Vquit_flag)) {
 	  Lisp_Object quit_event = Fmake_event(Qnil, Qnil);
-	  struct Lisp_Event *e = XEVENT (quit_event);
+	  Lisp_Event *e = XEVENT (quit_event);
 	  /* if quit happened during menu acceleration, pretend we read it */
 	  struct console *con = XCONSOLE (Fselected_console ());
 	  int ch = CONSOLE_QUIT_CHAR (con);
 	  character_to_event (ch, e, con, 1, 1);
 Lisp_Object win = Fselected_window (Qnil);
 #if 0
 /* If the last command deleted the frame, `win' might be nil.
 It seems safest to do nothing in this case. */
-/* ### This doesn't really fix the problem,
+/* #### This doesn't really fix the problem,
 if delete-frame is called by some hook */
 if (NILP (win))
 return;
 #endif
 */
 (event))
 {
 /* This function can GC */
 struct command_builder *command_builder;
-struct Lisp_Event *ev;
+Lisp_Event *ev;
 Lisp_Object console;
 Lisp_Object channel;
 CHECK_LIVE_EVENT (event);
 ev = XEVENT (event);
 reinit_vars_of_event_stream (void)
 {
 recent_keys_ring_index = 0;
 recent_keys_ring_size = 100;
 num_input_chars = 0;
-Vtimeout_free_list = make_lcrecord_list (sizeof (struct Lisp_Timeout),
+Vtimeout_free_list = make_lcrecord_list (sizeof (Lisp_Timeout),
 					   &lrecord_timeout);
 staticpro_nodump (&Vtimeout_free_list);
 the_low_level_timeout_blocktype =
 Blocktype_new (struct low_level_timeout_blocktype);
 something_happened = 0;

Mercurial > hg > xemacs-beta

comparison src/event-stream.c @ 440:8de8e3f6228a r21-2-28