(swallow_events): New arg DO_DISPLAY.

(swallow_events): Process timer_event events here.
(detect_input_pending_run_timers): New function.

(Vtimer_idle_list): New variable.
(syms_of_keyboard): Set up Lisp var.
(timer_check): Check for idle-time timers too.
Expect timers to have 8 slots.  Initialize triggertime.
(timer_start_idle, timer_stop_idle): New functions.

(get_input_pending): New arg do_timers_now.
(readable_events): Likewise.
(Finput_pending_p): Use get_input_pending, so we can specify
1 for do_timers_now.

(timer_check): Check for difference being zero.

1 files changed, 206 insertions, 121 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index 768036d803d..50d39831497 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -474,9 +474,12 @@ extern char *x_get_keysym_name ();
 
 Lisp_Object Qpolling_period;
 
-/* List of active timers.  Appears in order of next scheduled event.  */
+/* List of absolute timers.  Appears in order of next scheduled event.  */
 Lisp_Object Vtimer_list;
 
+/* List of idle time timers.  Appears in order of next scheduled event.  */
+Lisp_Object Vtimer_idle_list;
+
 extern Lisp_Object Vprint_level, Vprint_length;
 
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
@@ -1809,6 +1812,8 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       goto non_reread;
     }
 
+  timer_start_idle ();
+
   /* If in middle of key sequence and minibuffer not active,
      start echoing if enough time elapses.  */
 
@@ -1888,25 +1893,11 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 	  && XINT (Vauto_save_timeout) > 0)
 	{
 	  Lisp_Object tem0;
-	  EMACS_TIME timer_delay;
-	  EMACS_TIME delay, difference;
-
-	  EMACS_SET_SECS (delay,
-			  delay_level * XFASTINT (Vauto_save_timeout) / 4);
-	  EMACS_SET_USECS (delay, 0);
-
-	  /* Don't wait longer than until the next timer will fire.  */
-	  timer_delay = timer_check (0);
-	  if (! EMACS_TIME_NEG_P (timer_delay))
-	    {
-	      EMACS_SUB_TIME (difference, timer_delay, delay);
-	      if (EMACS_TIME_NEG_P (difference))
-		delay = timer_delay;
-	    }
 
 	  save_getcjmp (save_jump);
 	  restore_getcjmp (local_getcjmp);
-	  tem0 = sit_for (EMACS_SECS (delay), EMACS_USECS (delay), 1, 1);
+	  tem0 = sit_for (delay_level * XFASTINT (Vauto_save_timeout) / 4,
+			  0, 1, 1);
 	  restore_getcjmp (save_jump);
 
 	  if (EQ (tem0, Qt))
@@ -1938,7 +1929,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 	    = XCONS (current_kboard->kbd_queue)->cdr;
 	  if (NILP (current_kboard->kbd_queue))
 	    current_kboard->kbd_queue_has_data = 0;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 #ifdef MULTI_FRAME
 	  if (EVENT_HAS_PARAMETERS (c)
 	      && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qswitch_frame))
@@ -2026,6 +2017,11 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 
  non_reread:
 
+  /* Now that we have read an event, Emacs is not idle--
+     unless the event was a timer event.  */
+  if (! (CONSP (c) && EQ (XCONS (c)->car, Qtimer_event)))
+    timer_stop_idle ();
+
   start_polling ();
 
   if (NILP (c))
@@ -2293,10 +2289,10 @@ tracking_off (old_value)
 	 input has been processed.  If the only input available was
 	 the sort that we have just disabled, then we need to call
 	 redisplay.  */
-      if (!readable_events ())
+      if (!readable_events (1))
 	{
 	  redisplay_preserve_echo_area ();
-	  get_input_pending (&input_pending);
+	  get_input_pending (&input_pending, 1);
 	}
     }
 }
@@ -2346,9 +2342,10 @@ some_mouse_moved ()
 /* Return true iff there are any events in the queue that read-char
    would return.  If this returns false, a read-char would block.  */
 static int
-readable_events ()
+readable_events (do_timers_now)
+     int do_timers_now;
 {
-  timer_check (1);
+  timer_check (do_timers_now);
   if (kbd_fetch_ptr != kbd_store_ptr)
     return 1;
 #ifdef HAVE_MOUSE
@@ -2548,17 +2545,6 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
 	break;
 #endif
 
-      /* Check when the next timer fires.  */
-      next_timer_delay = timer_check (0);
-      if (EMACS_SECS (next_timer_delay) == 0
-	  && EMACS_USECS (next_timer_delay) == 0)
-	break;
-      if (EMACS_TIME_NEG_P (next_timer_delay))
-	{
-	  EMACS_SET_SECS (next_timer_delay, 0);
-	  EMACS_SET_USECS (next_timer_delay, 0);
-	}
-
       /* If the quit flag is set, then read_char will return
 	 quit_char, so that counts as "available input."  */
       if (!NILP (Vquit_flag))
@@ -2584,9 +2570,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
 	Lisp_Object minus_one;
 
 	XSETINT (minus_one, -1);
-	wait_reading_process_input (EMACS_SECS (next_timer_delay),
-				    EMACS_USECS (next_timer_delay),
-				    minus_one, 1);
+	wait_reading_process_input (0, 0, minus_one, 1);
 
 	if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
 	  /* Pass 1 for EXPECT since we just waited to have input.  */
@@ -2631,7 +2615,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
 	     and process it again.  */
 	  copy = *event;
 	  kbd_fetch_ptr = event + 1;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 	  x_handle_selection_request (&copy);
 #else
 	  /* We're getting selection request events, but we don't have
@@ -2648,7 +2632,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
 	  /* Remove it from the buffer before processing it.  */
 	  copy = *event;
 	  kbd_fetch_ptr = event + 1;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 	  x_handle_selection_clear (&copy);
 #else
 	  /* We're getting selection request events, but we don't have
@@ -2689,7 +2673,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
       else if (event->kind == menu_bar_activate_event)
 	{
 	  kbd_fetch_ptr = event + 1;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 	  x_activate_menubar (XFRAME (event->frame_or_window));
 	}
 #endif
@@ -2801,7 +2785,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
        something for us to read!  */
     abort ();
 
-  input_pending = readable_events ();
+  input_pending = readable_events (0);
 
 #ifdef MULTI_FRAME
   Vlast_event_frame = internal_last_event_frame;
@@ -2814,7 +2798,8 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
    then return, without reading any user-visible events.  */
 
 void
-swallow_events ()
+swallow_events (do_display)
+     int do_display;
 {
   while (kbd_fetch_ptr != kbd_store_ptr)
     {
@@ -2838,7 +2823,7 @@ swallow_events ()
 	     and process it again.  */
 	  copy = *event;
 	  kbd_fetch_ptr = event + 1;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 	  x_handle_selection_request (&copy);
 #else
 	  /* We're getting selection request events, but we don't have
@@ -2856,7 +2841,7 @@ swallow_events ()
 	  copy = *event;
 
 	  kbd_fetch_ptr = event + 1;
-	  input_pending = readable_events ();
+	  input_pending = readable_events (0);
 	  x_handle_selection_clear (&copy);
 #else
 	  /* We're getting selection request events, but we don't have
@@ -2864,13 +2849,69 @@ swallow_events ()
 	  abort ();
 #endif
 	}
+      else if (event->kind == timer_event)
+	{
+	  Lisp_Object tem, lisp_event;
+	  int was_locked = single_kboard;
+
+	  tem = get_keymap_1 (Vspecial_event_map, 0, 0);
+	  tem = get_keyelt (access_keymap (tem, Qtimer_event, 0, 0),
+			    1);
+	  lisp_event = Fcons (Qtimer_event,
+			      Fcons (Fcdr (event->frame_or_window), Qnil));
+	  kbd_fetch_ptr = event + 1;
+	  if (kbd_fetch_ptr == kbd_store_ptr)
+	    input_pending = 0;
+	  Fcommand_execute (tem, Qnil, Fvector (1, &lisp_event));
+	  if (do_display)
+	    redisplay_preserve_echo_area ();
+
+	  /* Resume allowing input from any kboard, if that was true before.  */
+	  if (!was_locked)
+	    any_kboard_state ();
+	}
       else
 	break;
     }
 
-  get_input_pending (&input_pending);
+  get_input_pending (&input_pending, 1);
 }
 
+static EMACS_TIME timer_idleness_start_time;
+
+/* Record the start of when Emacs is idle,
+   for the sake of running idle-time timers.  */
+
+timer_start_idle ()
+{
+  Lisp_Object timers;
+
+  /* If we are already in the idle state, do nothing.  */
+  if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+    return;
+
+  EMACS_GET_TIME (timer_idleness_start_time);
+
+  /* Mark all idle-time timers as once again candidates for running.  */
+  for (timers = Vtimer_idle_list; CONSP (timers); timers = XCONS (timers)->cdr)
+    {
+      Lisp_Object timer;
+
+      timer = XCONS (timers)->car;
+
+      if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
+	continue;
+      XVECTOR (timer)->contents[0] = Qnil;
+    }
+}
+
+/* Record that Emacs is no longer idle, so stop running idle-time timers.  */
+
+timer_stop_idle ()
+{
+  EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
+}
+
 /* Check whether a timer has fired.  To prevent larger problems we simply
    disregard elements that are not proper timers.  Do not make a circular
    timer list for the time being.
@@ -2892,6 +2933,7 @@ timer_check (do_it_now)
   /* Nonzero if we generate some events.  */
   int events_generated = 0;
   struct gcpro gcpro1, gcpro2;
+  int listnum;
 
   EMACS_SET_SECS (nexttime, -1);
   EMACS_SET_USECS (nexttime, -1);
@@ -2900,89 +2942,112 @@ timer_check (do_it_now)
   timer = Qnil;
   GCPRO2 (timers, timer);
 
-  if (CONSP (timers))
+  if (CONSP (Vtimer_list) || CONSP (Vtimer_idle_list))
     EMACS_GET_TIME (now);
 
-  while (CONSP (timers))
+  for (listnum = 0; listnum < 2; listnum++)
     {
-      int triggertime;
-      Lisp_Object *vector;
-      EMACS_TIME timer_time;
-      EMACS_TIME difference;
-
-      timer = XCONS (timers)->car;
-      timers = XCONS (timers)->cdr;
+      EMACS_TIME compare_time;
 
-      if (!VECTORP (timer) || XVECTOR (timer)->size != 7)
-	continue;
-      vector = XVECTOR (timer)->contents;
-
-      if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
-	  || !INTEGERP (vector[3]))
-	continue;
+      /* Always first scan the absolute timer list.  */
+      if (listnum == 0)
+	{
+	  timers = Vtimer_list;
+	  compare_time = now;
+	}
+      /* If Emacs is idle, scan the idle timer list
+	 using the length of idleness as the time value.  */
+      else if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+	{
+	  timers = Vtimer_idle_list;
+	  EMACS_SUB_TIME (compare_time, now, timer_idleness_start_time);
+	}
+      else
+	break;
 
-      EMACS_SET_SECS (timer_time,
-		      (XINT (vector[1]) << 16) | (XINT (vector[2])));
-      EMACS_SET_USECS (timer_time, XINT (vector[3]));
-      EMACS_SUB_TIME (difference, timer_time, now);
-      /* If event is past, run it if it hasn't been run.  */
-      if (EMACS_TIME_NEG_P (difference))
+      while (CONSP (timers))
 	{
-	  if (NILP (vector[0]))
+	  int triggertime = EMACS_SECS (now);
+	  Lisp_Object *vector;
+	  EMACS_TIME timer_time;
+	  EMACS_TIME difference;
+
+	  timer = XCONS (timers)->car;
+	  timers = XCONS (timers)->cdr;
+
+	  if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
+	    continue;
+	  vector = XVECTOR (timer)->contents;
+
+	  if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
+	      || !INTEGERP (vector[3]))
+	    continue;
+
+	  EMACS_SET_SECS (timer_time,
+			  (XINT (vector[1]) << 16) | (XINT (vector[2])));
+	  EMACS_SET_USECS (timer_time, XINT (vector[3]));
+	  EMACS_SUB_TIME (difference, timer_time, compare_time);
+	  /* If event is past, run it if it hasn't been run.  */
+	  if (EMACS_TIME_NEG_P (difference)
+	      || (EMACS_SECS (difference) == 0
+		  && EMACS_USECS (difference) == 0))
 	    {
-	      /* Mark the timer as triggered to prevent problems if the lisp
-		 code fails to reschedule it right.  */
-	      vector[0] = Qt;
-
-	      /* Run the timer or queue a timer event.  */
-	      if (do_it_now)
+	      if (NILP (vector[0]))
 		{
-		  Lisp_Object tem, event;
-		  int was_locked = single_kboard;
+		  /* Mark the timer as triggered to prevent problems if the lisp
+		     code fails to reschedule it right.  */
+		  vector[0] = Qt;
 
-		  tem = get_keymap_1 (Vspecial_event_map, 0, 0);
-		  tem = get_keyelt (access_keymap (tem, Qtimer_event, 0, 0),
-				    1);
-		  event = Fcons (Qtimer_event, Fcons (timer, Qnil));
-		  Fcommand_execute (tem, Qnil, Fvector (1, &event));
+		  /* Run the timer or queue a timer event.  */
+		  if (do_it_now)
+		    {
+		      Lisp_Object tem, event;
+		      int was_locked = single_kboard;
 
-		  /* Resume allowing input from any kboard, if that was true before.  */
-		  if (!was_locked)
-		    any_kboard_state ();
+		      tem = get_keymap_1 (Vspecial_event_map, 0, 0);
+		      tem = get_keyelt (access_keymap (tem, Qtimer_event, 0, 0),
+					1);
+		      event = Fcons (Qtimer_event, Fcons (timer, Qnil));
+		      Fcommand_execute (tem, Qnil, Fvector (1, &event));
 
-		  /* Since we have handled the event,
-		     we don't need to tell the caller to wake up and do it.  */
-		}
-	      else
-		{
-		  /* Generate a timer event so the caller will handle it.  */
-		  struct input_event event;
-
-		  event.kind = timer_event;
-		  event.modifiers = 0;
-		  event.x = event.y = Qnil;
-		  event.timestamp = triggertime;
-		  /* Store the timer in the frame slot.  */
-		  event.frame_or_window = Fcons (Fselected_frame (), timer);
-		  kbd_buffer_store_event (&event);
-
-		  /* Tell caller to handle this event right away.  */
-		  events_generated = 1;
-		  EMACS_SET_SECS (nexttime, 0);
-		  EMACS_SET_USECS (nexttime, 0);
+		      /* Resume allowing input from any kboard, if that was true before.  */
+		      if (!was_locked)
+			any_kboard_state ();
+
+		      /* Since we have handled the event,
+			 we don't need to tell the caller to wake up and do it.  */
+		    }
+		  else
+		    {
+		      /* Generate a timer event so the caller will handle it.  */
+		      struct input_event event;
+
+		      event.kind = timer_event;
+		      event.modifiers = 0;
+		      event.x = event.y = Qnil;
+		      event.timestamp = triggertime;
+		      /* Store the timer in the frame slot.  */
+		      event.frame_or_window = Fcons (Fselected_frame (), timer);
+		      kbd_buffer_store_event (&event);
+
+		      /* Tell caller to handle this event right away.  */
+		      events_generated = 1;
+		      EMACS_SET_SECS (nexttime, 0);
+		      EMACS_SET_USECS (nexttime, 0);
+		    }
 		}
 	    }
-	}
-      else
-	/* When we encounter a timer that is still waiting,
-	   return the amount of time to wait before it is ripe.  */
-	{
-	  UNGCPRO;
-	  /* But if we generated an event,
-	     tell the caller to handle it now.  */
-	  if (events_generated)
-	    return nexttime;
-	  return difference;
+	  else
+	    /* When we encounter a timer that is still waiting,
+	       return the amount of time to wait before it is ripe.  */
+	    {
+	      UNGCPRO;
+	      /* But if we generated an event,
+		 tell the caller to handle it now.  */
+	      if (events_generated)
+		return nexttime;
+	      return difference;
+	    }
 	}
     }
   /* No timers are pending in the future.  */
@@ -4428,14 +4493,17 @@ lucid_event_type_list_p (object)
 /* Store into *addr a value nonzero if terminal input chars are available.
    Serves the purpose of ioctl (0, FIONREAD, addr)
    but works even if FIONREAD does not exist.
-   (In fact, this may actually read some input.)  */
+   (In fact, this may actually read some input.)
+
+   If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.  */
 
 static void
-get_input_pending (addr)
+get_input_pending (addr, do_timers_now)
      int *addr;
+     int do_timers_now;
 {
   /* First of all, have we already counted some input?  */
-  *addr = !NILP (Vquit_flag) || readable_events ();
+  *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
 
   /* If input is being read as it arrives, and we have none, there is none.  */
   if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
@@ -4443,7 +4511,7 @@ get_input_pending (addr)
 
   /* Try to read some input and see how much we get.  */
   gobble_input (0);
-  *addr = !NILP (Vquit_flag) || readable_events ();
+  *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
 }
 
 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary.  */
@@ -6786,11 +6854,23 @@ current_active_maps (maps_p)
   return nmaps;
 }
 
+/* Return nonzero if input events are pending.  */
 
 detect_input_pending ()
 {
   if (!input_pending)
-    get_input_pending (&input_pending);
+    get_input_pending (&input_pending, 0);
+
+  return input_pending;
+}
+
+/* Return nonzero if input events are pending.
+   Execute timers immediately; don't make events for them.  */
+
+detect_input_pending_run_timers ()
+{
+  if (!input_pending)
+    get_input_pending (&input_pending, 1);
 
   return input_pending;
 }
@@ -6811,7 +6891,8 @@ Actually, the value is nil only if we can be sure that no input is available.")
   if (!NILP (Vunread_command_events) || unread_command_char != -1)
     return (Qt);
 
-  return detect_input_pending () ? Qt : Qnil;
+  get_input_pending (&input_pending, 1);
+  return input_pending > 0 ? Qt : Qnil;
 }
 
 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
@@ -7862,8 +7943,12 @@ If the value is non-nil and not a number, we wait 2 seconds.");
   Vcolumn_number_mode = Qnil;
 
   DEFVAR_LISP ("timer-list", &Vtimer_list,
-    "List of active timers in order of increasing time");
+    "List of active absolute time timers in order of increasing time");
   Vtimer_list = Qnil;
+
+  DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list,
+    "List of active idle-time timers in order of increasing time");
+  Vtimer_idle_list = Qnil;
 }
 
 keys_of_keyboard ()