[bpt/emacs.git] / lisp / gnus / gnus-demon.el

;;; gnus-demon.el --- daemonic Gnus behaviour

;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Keywords: news

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;;; Code:

(eval-when-compile (require 'cl))

(require 'gnus)
(require 'gnus-int)
(require 'nnheader)
(require 'nntp)
(require 'nnmail)
(require 'gnus-util)

(autoload 'parse-time-string "parse-time" nil nil)

(defgroup gnus-demon nil
  "Demonic behavior."
  :group 'gnus)

(defcustom gnus-demon-handlers nil
  "Alist of daemonic handlers to be run at intervals.
Each handler is a list on the form

\(FUNCTION TIME IDLE)

FUNCTION is the function to be called.
TIME is the number of `gnus-demon-timestep's between each call.
If nil, never call.  If t, call each `gnus-demon-timestep'.
If IDLE is t, only call if Emacs has been idle for a while.  If IDLE
is a number, only call when Emacs has been idle more than this number
of `gnus-demon-timestep's.  If IDLE is nil, don't care about
idleness.  If IDLE is a number and TIME is nil, then call once each
time Emacs has been idle for IDLE `gnus-demon-timestep's."
  :group 'gnus-demon
  :type '(repeat (list function
		       (choice :tag "Time"
			       (const :tag "never" nil)
			       (const :tag "one" t)
			       (integer :tag "steps" 1))
		       (choice :tag "Idle"
			       (const :tag "don't care" nil)
			       (const :tag "for a while" t)
			       (integer :tag "steps" 1)))))

(defcustom gnus-demon-timestep 60
  "*Number of seconds in each demon timestep."
  :group 'gnus-demon
  :type 'integer)

;;; Internal variables.

(defvar gnus-demon-timer nil)
(defvar gnus-demon-idle-has-been-called nil)
(defvar gnus-demon-idle-time 0)
(defvar gnus-demon-handler-state nil)
(defvar gnus-demon-last-keys nil)
(defvar gnus-inhibit-demon nil
  "*If non-nil, no daemonic function will be run.")

;;; Functions.

(defun gnus-demon-add-handler (function time idle)
  "Add the handler FUNCTION to be run at TIME and IDLE."
  ;; First remove any old handlers that use this function.
  (gnus-demon-remove-handler function)
  ;; Then add the new one.
  (push (list function time idle) gnus-demon-handlers)
  (gnus-demon-init))

(defun gnus-demon-remove-handler (function &optional no-init)
  "Remove the handler FUNCTION from the list of handlers."
  (gnus-pull function gnus-demon-handlers)
  (unless no-init
    (gnus-demon-init)))

(defun gnus-demon-init ()
  "Initialize the Gnus daemon."
  (interactive)
  (gnus-demon-cancel)
  (when gnus-demon-handlers
    ;; Set up the timer.
    (setq gnus-demon-timer
	  (run-at-time
	   gnus-demon-timestep gnus-demon-timestep 'gnus-demon))
    ;; Reset control variables.
    (setq gnus-demon-handler-state
	  (mapcar
	   (lambda (handler)
	     (list (car handler) (gnus-demon-time-to-step (nth 1 handler))
		   (nth 2 handler)))
	   gnus-demon-handlers))
    (setq gnus-demon-idle-time 0)
    (setq gnus-demon-idle-has-been-called nil)))

(gnus-add-shutdown 'gnus-demon-cancel 'gnus)

(defun gnus-demon-cancel ()
  "Cancel any Gnus daemons."
  (interactive)
  (when gnus-demon-timer
    (nnheader-cancel-timer gnus-demon-timer))
  (setq gnus-demon-timer nil
	gnus-demon-idle-has-been-called nil)
  (condition-case ()
      (nnheader-cancel-function-timers 'gnus-demon)
    (error t)))

(defun gnus-demon-is-idle-p ()
  "Whether Emacs is idle or not."
  ;; We do this simply by comparing the 100 most recent keystrokes
  ;; with the ones we had last time.  If they are the same, one might
  ;; guess that Emacs is indeed idle.  This only makes sense if one
  ;; calls this function seldom -- like once a minute, which is what
  ;; we do here.
  (let ((keys (recent-keys)))
    (or (equal keys gnus-demon-last-keys)
	(progn
	  (setq gnus-demon-last-keys keys)
	  nil))))

(defun gnus-demon-time-to-step (time)
  "Find out how many seconds to TIME, which is on the form \"17:43\"."
  (if (not (stringp time))
      time
    (let* ((now (current-time))
	   ;; obtain NOW as discrete components -- make a vector for speed
	   (nowParts (decode-time now))
	   ;; obtain THEN as discrete components
	   (thenParts (parse-time-string time))
	   (thenHour (elt thenParts 2))
	   (thenMin (elt thenParts 1))
	   ;; convert time as elements into number of seconds since EPOCH.
	   (then (encode-time 0
			      thenMin
			      thenHour
			      ;; If THEN is earlier than NOW, make it
			      ;; same time tomorrow.  Doc for encode-time
			      ;; says that this is OK.
			      (+ (elt nowParts 3)
				 (if (or (< thenHour (elt nowParts 2))
					 (and (= thenHour (elt nowParts 2))
					      (<= thenMin (elt nowParts 1))))
				     1 0))
			      (elt nowParts 4)
			      (elt nowParts 5)
			      (elt nowParts 6)
			      (elt nowParts 7)
			      (elt nowParts 8)))
	   ;; calculate number of seconds between NOW and THEN
	   (diff (+ (* 65536 (- (car then) (car now)))
		    (- (cadr then) (cadr now)))))
      ;; return number of timesteps in the number of seconds
      (round (/ diff gnus-demon-timestep)))))

(defun gnus-demon ()
  "The Gnus daemon that takes care of running all Gnus handlers."
  ;; Increase or reset the time Emacs has been idle.
  (if (gnus-demon-is-idle-p)
      (incf gnus-demon-idle-time)
    (setq gnus-demon-idle-time 0)
    (setq gnus-demon-idle-has-been-called nil))
  ;; Disable all daemonic stuff if we're in the minibuffer
  (when (and (not (window-minibuffer-p (selected-window)))
	     (not gnus-inhibit-demon))
    ;; Then we go through all the handler and call those that are
    ;; sufficiently ripe.
    (let ((handlers gnus-demon-handler-state)
	  (gnus-inhibit-demon t)
	  ;; Try to avoid dialog boxes, e.g. by Mailcrypt.
	  ;; Unfortunately, Emacs 20's `message-or-box...' doesn't
	  ;; obey `use-dialog-box'.
	  use-dialog-box (last-nonmenu-event 10)
	  handler time idle)
      (while handlers
	(setq handler (pop handlers))
	(cond
	 ((numberp (setq time (nth 1 handler)))
	  ;; These handlers use a regular timeout mechanism.  We decrease
	  ;; the timer if it hasn't reached zero yet.
	  (unless (zerop time)
	    (setcar (nthcdr 1 handler) (decf time)))
	  (and (zerop time)		; If the timer now is zero...
	       ;; Test for appropriate idleness
	       (progn
		 (setq idle (nth 2 handler))
		 (cond
		  ((null idle) t)	; Don't care about idle.
		  ((numberp idle)	; Numerical idle...
		   (< idle gnus-demon-idle-time)) ; Idle timed out.
		  (t (< 0 gnus-demon-idle-time)))) ; Or just need to be idle.
	       ;; So we call the handler.
	       (gnus-with-local-quit
		 (ignore-errors (funcall (car handler)))
		 ;; And reset the timer.
		 (setcar (nthcdr 1 handler)
			 (gnus-demon-time-to-step
			  (nth 1 (assq (car handler) gnus-demon-handlers)))))))
	 ;; These are only supposed to be called when Emacs is idle.
	 ((null (setq idle (nth 2 handler)))
	  ;; We do nothing.
	  )
	 ((and (not (numberp idle))
	       (gnus-demon-is-idle-p))
	  ;; We want to call this handler each and every time that
	  ;; Emacs is idle.
	  (gnus-with-local-quit
	    (ignore-errors (funcall (car handler)))))
	 (t
	  ;; We want to call this handler only if Emacs has been idle
	  ;; for a specified number of timesteps.
	  (and (not (memq (car handler) gnus-demon-idle-has-been-called))
	       (< idle gnus-demon-idle-time)
	       (gnus-demon-is-idle-p)
	       (gnus-with-local-quit
		 (ignore-errors (funcall (car handler)))
		 ;; Make sure the handler won't be called once more in
		 ;; this idle-cycle.
		 (push (car handler) gnus-demon-idle-has-been-called)))))))))

(defun gnus-demon-add-nocem ()
  "Add daemonic NoCeM handling to Gnus."
  (gnus-demon-add-handler 'gnus-demon-scan-nocem 60 30))

(defun gnus-demon-scan-nocem ()
  "Scan NoCeM groups for NoCeM messages."
  (save-window-excursion
    (gnus-nocem-scan-groups)))

(defun gnus-demon-add-disconnection ()
  "Add daemonic server disconnection to Gnus."
  (gnus-demon-add-handler 'gnus-demon-close-connections nil 30))

(defun gnus-demon-close-connections ()
  (save-window-excursion
    (gnus-close-backends)))

(defun gnus-demon-add-nntp-close-connection ()
  "Add daemonic nntp server disconnection to Gnus.
If no commands have gone out via nntp during the last five
minutes, the connection is closed."
  (gnus-demon-add-handler 'gnus-demon-nntp-close-connections 5 nil))

(defun gnus-demon-nntp-close-connection ()
  (save-window-excursion
    (when (time-less-p '(0 300) (time-since nntp-last-command-time))
      (nntp-close-server))))

(defun gnus-demon-add-scanmail ()
  "Add daemonic scanning of mail from the mail backends."
  (gnus-demon-add-handler 'gnus-demon-scan-mail 120 60))

(defun gnus-demon-scan-mail ()
  (save-window-excursion
    (let ((servers gnus-opened-servers)
	  server
	  (nnmail-fetched-sources (list t)))
      (while (setq server (car (pop servers)))
	(and (gnus-check-backend-function 'request-scan (car server))
	     (or (gnus-server-opened server)
		 (gnus-open-server server))
	     (gnus-request-scan nil server))))))

(defun gnus-demon-add-rescan ()
  "Add daemonic scanning of new articles from all backends."
  (gnus-demon-add-handler 'gnus-demon-scan-news 120 60))

(defun gnus-demon-scan-news ()
  (let ((win (current-window-configuration)))
    (unwind-protect
	(save-window-excursion
	  (save-excursion
	    (when (gnus-alive-p)
	      (save-excursion
		(set-buffer gnus-group-buffer)
		(gnus-group-get-new-news)))))
      (set-window-configuration win))))

(defun gnus-demon-add-scan-timestamps ()
  "Add daemonic updating of timestamps in empty newgroups."
  (gnus-demon-add-handler 'gnus-demon-scan-timestamps nil 30))

(defun gnus-demon-scan-timestamps ()
  "Set the timestamp on all newsgroups with no unread and no ticked articles."
  (when (gnus-alive-p)
    (let ((cur-time (current-time))
	  (newsrc (cdr gnus-newsrc-alist))
	  info group unread has-ticked)
      (while (setq info (pop newsrc))
	(setq group (gnus-info-group info)
	      unread (gnus-group-unread group)
	      has-ticked (cdr (assq 'tick (gnus-info-marks info))))
	(when (and (numberp unread)
		   (= unread 0)
		   (not has-ticked))
	  (gnus-group-set-parameter group 'timestamp cur-time))))))

(provide 'gnus-demon)

;; arch-tag: 8dd5cd3d-6ae4-46b4-9b15-f5fca09fd392
;;; gnus-demon.el ends here
Commit	Line	Data
eec82323	1	;;; gnus-demon.el --- daemonic Gnus behaviour
23f87bed	2
b6c2d8c6	3	;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
e3fe4da0	4	;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
eec82323	5
6748645f	6	;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
eec82323 LMI	7	;; Keywords: news
	8
	9	;; This file is part of GNU Emacs.
	10
	11	;; GNU Emacs is free software; you can redistribute it and/or modify
	12	;; it under the terms of the GNU General Public License as published by
5a9dffec	13	;; the Free Software Foundation; either version 3, or (at your option)
eec82323 LMI	14	;; any later version.
	15
	16	;; GNU Emacs is distributed in the hope that it will be useful,
	17	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	;; GNU General Public License for more details.
	20
	21	;; You should have received a copy of the GNU General Public License
	22	;; along with GNU Emacs; see the file COPYING. If not, write to the
3a35cf56 LK	23	;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
3a35cf56 LK	24	;; Boston, MA 02110-1301, USA.
eec82323 LMI	25
	26	;;; Commentary:
	27
	28	;;; Code:
	29
7df7482d RS	30	(eval-when-compile (require 'cl))
7df7482d RS	31
eec82323 LMI	32	(require 'gnus)
	33	(require 'gnus-int)
	34	(require 'nnheader)
6748645f LMI	35	(require 'nntp)
	36	(require 'nnmail)
	37	(require 'gnus-util)
eec82323	38
498063ec MB	39	(autoload 'parse-time-string "parse-time" nil nil)
498063ec MB	40
eec82323	41	(defgroup gnus-demon nil
4525646f	42	"Demonic behavior."
eec82323 LMI	43	:group 'gnus)
	44
	45	(defcustom gnus-demon-handlers nil
	46	"Alist of daemonic handlers to be run at intervals.
	47	Each handler is a list on the form
	48
	49	\(FUNCTION TIME IDLE)
	50
	51	FUNCTION is the function to be called.
	52	TIME is the number of `gnus-demon-timestep's between each call.
	53	If nil, never call. If t, call each `gnus-demon-timestep'.
	54	If IDLE is t, only call if Emacs has been idle for a while. If IDLE
	55	is a number, only call when Emacs has been idle more than this number
	56	of `gnus-demon-timestep's. If IDLE is nil, don't care about
	57	idleness. If IDLE is a number and TIME is nil, then call once each
	58	time Emacs has been idle for IDLE `gnus-demon-timestep's."
	59	:group 'gnus-demon
	60	:type '(repeat (list function
	61	(choice :tag "Time"
	62	(const :tag "never" nil)
	63	(const :tag "one" t)
	64	(integer :tag "steps" 1))
	65	(choice :tag "Idle"
	66	(const :tag "don't care" nil)
	67	(const :tag "for a while" t)
	68	(integer :tag "steps" 1)))))
	69
	70	(defcustom gnus-demon-timestep 60
	71	"*Number of seconds in each demon timestep."
	72	:group 'gnus-demon
	73	:type 'integer)
	74
	75	;;; Internal variables.
	76
	77	(defvar gnus-demon-timer nil)
	78	(defvar gnus-demon-idle-has-been-called nil)
	79	(defvar gnus-demon-idle-time 0)
	80	(defvar gnus-demon-handler-state nil)
	81	(defvar gnus-demon-last-keys nil)
	82	(defvar gnus-inhibit-demon nil
	83	"*If non-nil, no daemonic function will be run.")
	84
eec82323 LMI	85	;;; Functions.
	86
	87	(defun gnus-demon-add-handler (function time idle)
	88	"Add the handler FUNCTION to be run at TIME and IDLE."
	89	;; First remove any old handlers that use this function.
	90	(gnus-demon-remove-handler function)
	91	;; Then add the new one.
	92	(push (list function time idle) gnus-demon-handlers)
	93	(gnus-demon-init))
	94
	95	(defun gnus-demon-remove-handler (function &optional no-init)
	96	"Remove the handler FUNCTION from the list of handlers."
6748645f	97	(gnus-pull function gnus-demon-handlers)
eec82323 LMI	98	(unless no-init
	99	(gnus-demon-init)))
	100
	101	(defun gnus-demon-init ()
	102	"Initialize the Gnus daemon."
	103	(interactive)
	104	(gnus-demon-cancel)
6748645f LMI	105	(when gnus-demon-handlers
6748645f LMI	106	;; Set up the timer.
eec82323	107	(setq gnus-demon-timer
01c52d31	108	(run-at-time
eec82323 LMI	109	gnus-demon-timestep gnus-demon-timestep 'gnus-demon))
	110	;; Reset control variables.
	111	(setq gnus-demon-handler-state
	112	(mapcar
	113	(lambda (handler)
	114	(list (car handler) (gnus-demon-time-to-step (nth 1 handler))
	115	(nth 2 handler)))
	116	gnus-demon-handlers))
	117	(setq gnus-demon-idle-time 0)
16409b0b	118	(setq gnus-demon-idle-has-been-called nil)))
eec82323 LMI	119
	120	(gnus-add-shutdown 'gnus-demon-cancel 'gnus)
	121
	122	(defun gnus-demon-cancel ()
	123	"Cancel any Gnus daemons."
	124	(interactive)
	125	(when gnus-demon-timer
	126	(nnheader-cancel-timer gnus-demon-timer))
	127	(setq gnus-demon-timer nil
6748645f	128	gnus-demon-idle-has-been-called nil)
eec82323 LMI	129	(condition-case ()
	130	(nnheader-cancel-function-timers 'gnus-demon)
	131	(error t)))
	132
	133	(defun gnus-demon-is-idle-p ()
	134	"Whether Emacs is idle or not."
	135	;; We do this simply by comparing the 100 most recent keystrokes
	136	;; with the ones we had last time. If they are the same, one might
	137	;; guess that Emacs is indeed idle. This only makes sense if one
	138	;; calls this function seldom -- like once a minute, which is what
	139	;; we do here.
	140	(let ((keys (recent-keys)))
	141	(or (equal keys gnus-demon-last-keys)
	142	(progn
	143	(setq gnus-demon-last-keys keys)
	144	nil))))
	145
	146	(defun gnus-demon-time-to-step (time)
	147	"Find out how many seconds to TIME, which is on the form \"17:43\"."
	148	(if (not (stringp time))
	149	time
a8151ef7	150	(let* ((now (current-time))
23f87bed MB	151	;; obtain NOW as discrete components -- make a vector for speed
	152	(nowParts (decode-time now))
	153	;; obtain THEN as discrete components
	154	(thenParts (parse-time-string time))
	155	(thenHour (elt thenParts 2))
	156	(thenMin (elt thenParts 1))
	157	;; convert time as elements into number of seconds since EPOCH.
	158	(then (encode-time 0
	159	thenMin
	160	thenHour
	161	;; If THEN is earlier than NOW, make it
	162	;; same time tomorrow. Doc for encode-time
	163	;; says that this is OK.
	164	(+ (elt nowParts 3)
	165	(if (or (< thenHour (elt nowParts 2))
	166	(and (= thenHour (elt nowParts 2))
	167	(<= thenMin (elt nowParts 1))))
	168	1 0))
	169	(elt nowParts 4)
	170	(elt nowParts 5)
	171	(elt nowParts 6)
	172	(elt nowParts 7)
	173	(elt nowParts 8)))
	174	;; calculate number of seconds between NOW and THEN
	175	(diff (+ (* 65536 (- (car then) (car now)))
	176	(- (cadr then) (cadr now)))))
a8151ef7 LMI	177	;; return number of timesteps in the number of seconds
a8151ef7 LMI	178	(round (/ diff gnus-demon-timestep)))))
eec82323 LMI	179
	180	(defun gnus-demon ()
	181	"The Gnus daemon that takes care of running all Gnus handlers."
	182	;; Increase or reset the time Emacs has been idle.
	183	(if (gnus-demon-is-idle-p)
	184	(incf gnus-demon-idle-time)
	185	(setq gnus-demon-idle-time 0)
	186	(setq gnus-demon-idle-has-been-called nil))
	187	;; Disable all daemonic stuff if we're in the minibuffer
	188	(when (and (not (window-minibuffer-p (selected-window)))
	189	(not gnus-inhibit-demon))
	190	;; Then we go through all the handler and call those that are
	191	;; sufficiently ripe.
	192	(let ((handlers gnus-demon-handler-state)
	193	(gnus-inhibit-demon t)
16409b0b GM	194	;; Try to avoid dialog boxes, e.g. by Mailcrypt.
	195	;; Unfortunately, Emacs 20's `message-or-box...' doesn't
	196	;; obey `use-dialog-box'.
	197	use-dialog-box (last-nonmenu-event 10)
eec82323 LMI	198	handler time idle)
	199	(while handlers
	200	(setq handler (pop handlers))
	201	(cond
	202	((numberp (setq time (nth 1 handler)))
	203	;; These handlers use a regular timeout mechanism. We decrease
	204	;; the timer if it hasn't reached zero yet.
	205	(unless (zerop time)
	206	(setcar (nthcdr 1 handler) (decf time)))
	207	(and (zerop time) ; If the timer now is zero...
	208	;; Test for appropriate idleness
	209	(progn
	210	(setq idle (nth 2 handler))
	211	(cond
	212	((null idle) t) ; Don't care about idle.
	213	((numberp idle) ; Numerical idle...
	214	(< idle gnus-demon-idle-time)) ; Idle timed out.
	215	(t (< 0 gnus-demon-idle-time)))) ; Or just need to be idle.
	216	;; So we call the handler.
996aa8c1	217	(gnus-with-local-quit
a8151ef7	218	(ignore-errors (funcall (car handler)))
eec82323 LMI	219	;; And reset the timer.
	220	(setcar (nthcdr 1 handler)
	221	(gnus-demon-time-to-step
	222	(nth 1 (assq (car handler) gnus-demon-handlers)))))))
	223	;; These are only supposed to be called when Emacs is idle.
	224	((null (setq idle (nth 2 handler)))
	225	;; We do nothing.
	226	)
a8151ef7 LMI	227	((and (not (numberp idle))
a8151ef7 LMI	228	(gnus-demon-is-idle-p))
eec82323 LMI	229	;; We want to call this handler each and every time that
eec82323 LMI	230	;; Emacs is idle.
996aa8c1	231	(gnus-with-local-quit
90e93246	232	(ignore-errors (funcall (car handler)))))
eec82323 LMI	233	(t
	234	;; We want to call this handler only if Emacs has been idle
	235	;; for a specified number of timesteps.
	236	(and (not (memq (car handler) gnus-demon-idle-has-been-called))
	237	(< idle gnus-demon-idle-time)
a8151ef7	238	(gnus-demon-is-idle-p)
996aa8c1	239	(gnus-with-local-quit
a8151ef7	240	(ignore-errors (funcall (car handler)))
eec82323 LMI	241	;; Make sure the handler won't be called once more in
	242	;; this idle-cycle.
	243	(push (car handler) gnus-demon-idle-has-been-called)))))))))
	244
	245	(defun gnus-demon-add-nocem ()
	246	"Add daemonic NoCeM handling to Gnus."
a8151ef7	247	(gnus-demon-add-handler 'gnus-demon-scan-nocem 60 30))
eec82323 LMI	248
	249	(defun gnus-demon-scan-nocem ()
	250	"Scan NoCeM groups for NoCeM messages."
	251	(save-window-excursion
	252	(gnus-nocem-scan-groups)))
	253
	254	(defun gnus-demon-add-disconnection ()
	255	"Add daemonic server disconnection to Gnus."
	256	(gnus-demon-add-handler 'gnus-demon-close-connections nil 30))
	257
	258	(defun gnus-demon-close-connections ()
	259	(save-window-excursion
	260	(gnus-close-backends)))
	261
6748645f LMI	262	(defun gnus-demon-add-nntp-close-connection ()
	263	"Add daemonic nntp server disconnection to Gnus.
	264	If no commands have gone out via nntp during the last five
	265	minutes, the connection is closed."
16409b0b	266	(gnus-demon-add-handler 'gnus-demon-nntp-close-connections 5 nil))
6748645f LMI	267
	268	(defun gnus-demon-nntp-close-connection ()
	269	(save-window-excursion
16409b0b	270	(when (time-less-p '(0 300) (time-since nntp-last-command-time))
6748645f LMI	271	(nntp-close-server))))
6748645f LMI	272
eec82323 LMI	273	(defun gnus-demon-add-scanmail ()
	274	"Add daemonic scanning of mail from the mail backends."
	275	(gnus-demon-add-handler 'gnus-demon-scan-mail 120 60))
	276
	277	(defun gnus-demon-scan-mail ()
	278	(save-window-excursion
	279	(let ((servers gnus-opened-servers)
16409b0b GM	280	server
16409b0b GM	281	(nnmail-fetched-sources (list t)))
eec82323 LMI	282	(while (setq server (car (pop servers)))
	283	(and (gnus-check-backend-function 'request-scan (car server))
	284	(or (gnus-server-opened server)
	285	(gnus-open-server server))
	286	(gnus-request-scan nil server))))))
	287
	288	(defun gnus-demon-add-rescan ()
	289	"Add daemonic scanning of new articles from all backends."
	290	(gnus-demon-add-handler 'gnus-demon-scan-news 120 60))
	291
	292	(defun gnus-demon-scan-news ()
6748645f LMI	293	(let ((win (current-window-configuration)))
	294	(unwind-protect
	295	(save-window-excursion
	296	(save-excursion
	297	(when (gnus-alive-p)
	298	(save-excursion
	299	(set-buffer gnus-group-buffer)
	300	(gnus-group-get-new-news)))))
	301	(set-window-configuration win))))
eec82323 LMI	302
	303	(defun gnus-demon-add-scan-timestamps ()
	304	"Add daemonic updating of timestamps in empty newgroups."
	305	(gnus-demon-add-handler 'gnus-demon-scan-timestamps nil 30))
	306
	307	(defun gnus-demon-scan-timestamps ()
	308	"Set the timestamp on all newsgroups with no unread and no ticked articles."
	309	(when (gnus-alive-p)
	310	(let ((cur-time (current-time))
	311	(newsrc (cdr gnus-newsrc-alist))
	312	info group unread has-ticked)
	313	(while (setq info (pop newsrc))
	314	(setq group (gnus-info-group info)
	315	unread (gnus-group-unread group)
	316	has-ticked (cdr (assq 'tick (gnus-info-marks info))))
	317	(when (and (numberp unread)
	318	(= unread 0)
	319	(not has-ticked))
	320	(gnus-group-set-parameter group 'timestamp cur-time))))))
	321
	322	(provide 'gnus-demon)
	323
cbee283d	324	;; arch-tag: 8dd5cd3d-6ae4-46b4-9b15-f5fca09fd392
eec82323	325	;;; gnus-demon.el ends here