+Sat Mar 2 11:38:26 1996 Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+
+ * gnus-vis.el (gnus-article-button-next-page): New function.
+ (gnus-article-button-prev-page): New function.
+ (gnus-insert-next-page-button): Use them.
+ (gnus-article-next-button): Wrong function name.
+
+ * gnus.el (gnus-get-unread-articles-in-group): Also reactivate
+ groups that alter their info.
+ (gnus-summary-next-thread): Would react badly to dummy roots.
+
+ * nndraft.el (nndraft-request-update-info): Return success.
+
+ * gnus.el (gnus-set-global-variables): Also copy the summary
+ buffer value.
+
+ * gnus-cite.el (gnus-cited-text-button-line-format): New default.
+ (gnus-article-hide-citation): Would add invisible buttons under
+ XEmacs.
+
+Fri Mar 1 20:52:28 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-msg.el (gnus-summary-resend-bounced-mail): Use
+ `mail-unsent-separator'.
+
+ * gnus.el (gnus-gather-threads-by-references): Change name.
+
+Fri Mar 1 20:25:21 1996 Brad Miller <bmiller@cs.umn.edu>
+
+ * gnus-gl.el: New version.
+
+Fri Mar 1 20:04:51 1996 Robert Pluim <pluim@xylint.co.uk>
+
+ * gnus-msg.el (gnus-mail-reply): Would handle Mail-Copies-To
+ `always'.
+
+Fri Mar 1 08:17:01 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el: Autoload `gnus-binary-mode'.
+ (gnus-group-prefixed-name): Would append "+" to group methods.
+
+ * gnus-topic.el (gnus-topic-list-active): Use the `force' param.
+
+ * gnus.el (gnus-group-change-level): Would bug out on ranks.
+ (gnus-backlog-request-article): Would choke on Message-IDs.
+ (gnus-group-change-level): Would bug out sometimes.
+ (gnus-configure-frame): Just push newly-created frames on the list
+ of frames to be closed on exit.
+ (gnus-method-equal): New function.
+
+ * nndoc.el (nndoc-generate-clari-briefs-head): Peel off whitespace
+ from the subjects.
+
+ * gnus-vis.el (gnus-group-make-menu-bar): Sorting entries were
+ wrong.
+
+ * gnus-cache.el (gnus-cache-update-article): New function.
+
+ * gnus.el (gnus-article-prev-page): Put point at first line.
+ (gnus-article-next-page): Ditto.
+ (gnus-get-unread-articles-in-group): Would bug out on dead
+ groups.
+ (gnus-summary-edit-article-done): Update cache.
+
+Thu Feb 29 10:50:02 1996 Steven L. Baur <steve@miranova.com>
+
+ * gnus-xmas.el (gnus-xmas-redefine): Add wrapper to
+ mail-strip-quoted-names.
+ (gnus-xmas-mail-strip-quoted-names): New function.
+
+ * gnus-msg.el (gnus-mail-reply): Use it.
+
+ * gnus-soup.el (gnus-soup-store): Use it.
+
+ * gnus-ems.el: mail-strip-quoted-names -> gnus-mail-strip-quoted-names.
+
+Fri Mar 1 07:12:38 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-read-newsrc-file): Make sure the .newsrc file
+ exists before reading it.
+ (gnus-group-restart): Ask before executing.
+
+Thu Feb 29 18:15:13 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-xmas.el (gnus-xmas-pick-menu-add,
+ gnus-xmas-binary-menu-add, gnus-xmas-tree-menu-add,
+ gnus-xmas-grouplens-menu-add): New functions.
+ (gnus-xmas-redefine): Use them.
+
+Thu Feb 29 18:10:05 1996 Brad Miller <bmiller@cs.umn.edu>
+
+ * gnus-gl.el: New version.
+
Thu Feb 29 14:28:06 1996 Lars Magne Ingebrigtsen <larsi@hler.ifi.uio.no>
+ * gnus.el: 0.48 is released.
+
* gnus.el (gnus-read-active-file): Wouldn't work on `some'.
Thu Feb 29 09:15:05 1996 Lars Ingebrigtsen <lars@eyesore.no>
(nnheader-replace-chars-in-string group ?. ?/))))
(if (stringp article) article (int-to-string article))))
+(defun gnus-cache-update-article (group article)
+ "If ARTICLE is in the cache, remove it and re-enter it."
+ (when (gnus-cache-possibly-remove-article article nil nil nil t)
+ (gnus-cache-possibly-enter-article
+ gnus-newsgroup-name article (gnus-summary-article-header article)
+ nil nil nil t)))
+
(defun gnus-cache-possibly-remove-article
(article ticked dormant unread &optional force)
"Possibly remove ARTICLE from the cache."
;;; Customization:
-(defvar gnus-cited-text-button-line-format "%(%{[...]%}%)"
+(defvar gnus-cited-text-button-line-format "%(%{[...]%}%)\n"
"Format of cited text buttons.")
(defvar gnus-cited-lines-visible nil
(setq beg (point))))
(when (and beg end)
(add-text-properties beg end props)
- (goto-char beg)
+ (goto-char (1- beg))
(put-text-property beg end 'gnus-type 'cite)
(gnus-article-add-button
(point)
(let (buffer-read-only)
(funcall
(if (text-property-any
- (car region) (cdr region)
+ (car region) (1- (cdr region))
(car gnus-hidden-properties) (cadr gnus-hidden-properties))
'remove-text-properties 'add-text-properties)
(car region) (cdr region) gnus-hidden-properties)))
(defalias 'gnus-extent-start-open 'ignore)
(defalias 'gnus-set-text-properties 'set-text-properties)
(defalias 'gnus-appt-select-lowest-window 'appt-select-lowest-window)
+(defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
(eval-and-compile
(autoload 'gnus-xmas-define "gnus-xmas")
;; USING GROUPLENS
;; How do I Rate an article??
;; Before you type n to go to the next article, hit a number from 1-5
-;; Type V r in the summary buffer and you will be prompted.
+;; Type r in the summary buffer and you will be prompted.
+;; Note that when you're in grouplens-minor-mode 'r' maskes the
+;; usual reply binding for 'r'
;;
;; What if, Gasp, I find a bug???
;; Please type M-x gnus-gl-submit-bug-report. This will set up a
(bbb-send-command bbb-process
(concat "login " grouplens-pseudonym))
(if (bbb-read-response bbb-process)
- (setq grouplens-bbb-token (extract-token-number))
+ (setq grouplens-bbb-token (bbb-extract-token-number))
(gnus-message 3 "Error: Grouplens login failed")))))
(gnus-message 3 "Error: you must set a pseudonym"))
grouplens-bbb-token)
-(defun extract-token-number ()
+(defun bbb-extract-token-number ()
(let ((token-pos (search-forward "token=" nil t) ))
(if (looking-at "[0-9]+")
(buffer-substring token-pos (match-end 0)))))
recommend using both scores and grouplens predictions together."
(setq grouplens-current-group groupname)
(if (member groupname grouplens-newsgroups)
- (let* ((mid-list (get-all-mids))
+ (let* ((mid-list (bbb-get-all-mids))
(predict-list (bbb-get-predictions mid-list groupname)))
(setq grouplens-previous-article nil)
;; scores-alist should be a list of lists:
(ding))))
(setq bbb-alist predict-list))))
-(defun get-all-mids ()
+(defun bbb-get-all-mids ()
(let ((index (nth 1 (assoc "message-id" gnus-header-index)))
(articles gnus-newsgroup-headers)
art this)
(setq grouplens-current-hashtable (make-hash-table :test 'equal :size 100))
(while
(cond ((looking-at "\\(<.*>\\) :nopred=")
- (push `(,(get-mid) ,gnus-summary-default-score nil s) resp)
+ (push `(,(bbb-get-mid) ,gnus-summary-default-score nil s) resp)
(forward-line 1)
t)
((looking-at "\\(<.*>\\) :pred=\\([0-9]\.[0-9][0-9]\\) :conflow=\\([0-9]\.[0-9][0-9]\\) :confhigh=\\([0-9]\.[0-9][0-9]\\)")
- (push `(,(get-mid) ,(get-pred) nil s) resp)
- (cl-puthash (get-mid)
- (list (get-pred) (get-confl) (get-confh))
+ (push `(,(bbb-get-mid) ,(bbb-get-pred) nil s) resp)
+ (cl-puthash (bbb-get-mid)
+ (list (bbb-get-pred) (bbb-get-confl) (bbb-get-confh))
grouplens-current-hashtable)
(forward-line 1)
t)
((looking-at "\\(<.*>\\) :pred=\\([0-9]\.[0-9][0-9]\\)")
- (push `(,(get-mid) ,(get-pred) nil s) resp)
- (cl-puthash (get-mid)
- (list (get-pred) 0 0)
+ (push `(,(bbb-get-mid) ,(bbb-get-pred) nil s) resp)
+ (cl-puthash (bbb-get-mid)
+ (list (bbb-get-pred) 0 0)
grouplens-current-hashtable)
(forward-line 1)
t)
;; around. Where the first parenthesized expression is the
;; message-id, and the second is the prediction. Since gnus assumes
;; that scores are integer values?? we round the prediction.
-(defun get-mid ()
+(defun bbb-get-mid ()
(buffer-substring (match-beginning 1) (match-end 1)))
-(defun get-pred ()
+(defun bbb-get-pred ()
(let ((tpred (round (string-to-int (buffer-substring
(match-beginning 2)
(match-end 2))))))
(* grouplens-score-scale-factor (+ grouplens-score-offset tpred))
1)))
-(defun get-confl ()
+(defun bbb-get-confl ()
(string-to-number (buffer-substring (match-beginning 3) (match-end 3))))
-(defun get-confh ()
+(defun bbb-get-confh ()
(string-to-number (buffer-substring (match-beginning 4) (match-end 4))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Prediction Display
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defconst rating-range 4.0)
+(defconst grplens-rating-range 4.0)
(defconst grplens-maxrating 5)
(defconst grplens-minrating 1)
(defconst grplens-predstringsize 12)
(setq iscore 5))))
(setq low 0)
(setq high 0))
- (if (and (grouplens-valid-score iscore)
+ (if (and (bbb-valid-score iscore)
(not (null mid)))
(cond
;; prediction-spot
((equal grouplens-prediction-display 'prediction-spot)
- (setq rate-string (fmt-prediction-spot rate-string iscore)))
+ (setq rate-string (bbb-fmt-prediction-spot rate-string iscore)))
;; confidence-interval
((equal grouplens-prediction-display 'confidence-interval)
- (setq rate-string (fmt-confidence-interval iscore low high)))
+ (setq rate-string (bbb-fmt-confidence-interval iscore low high)))
;; prediction-bar
((equal grouplens-prediction-display 'prediction-bar)
- (setq rate-string (fmt-prediction-bar rate-string iscore)))
+ (setq rate-string (bbb-fmt-prediction-bar rate-string iscore)))
;; confidence-bar
((equal grouplens-prediction-display 'confidence-bar)
(setq rate-string (format "| %4.2f |" iscore)))
(setq rate-string (format "| %4.2f |" iscore)))
;; prediction-num
((equal grouplens-prediction-display 'prediction-num)
- (setq rate-string (fmt-prediction-num iscore)))
+ (setq rate-string (bbb-fmt-prediction-num iscore)))
;; confidence-plus-minus
((equal grouplens-prediction-display 'confidence-plus-minus)
- (setq rate-string (fmt-confidence-plus-minus iscore low high))
+ (setq rate-string (bbb-fmt-confidence-plus-minus iscore low high))
)
(t (gnus-message 3 "Invalid prediction display type")))
(aset rate-string 5 ?N) (aset rate-string 6 ?A))
;; Init rate-string
(aset rate-string 0 ?|)
(aset rate-string 11 ?|)
-
+ (unless (equal grouplens-prediction-display 'prediction-num)
+ (cond ((< pred 0)
+ (setq pred 1))
+ ((> pred 5)
+ (setq pred 5))))
;; If no entry in BBB hash mark rate string as NA and return
(cond
((null hashent)
rate-string)
((equal grouplens-prediction-display 'prediction-spot)
- (fmt-prediction-spot rate-string pred))
+ (bbb-fmt-prediction-spot rate-string pred))
((equal grouplens-prediction-display 'confidence-interval)
- (fmt-confidence-interval pred low high))
+ (bbb-fmt-confidence-interval pred low high))
((equal grouplens-prediction-display 'prediction-bar)
- (fmt-prediction-bar rate-string pred))
+ (bbb-fmt-prediction-bar rate-string pred))
((equal grouplens-prediction-display 'confidence-bar)
(format "| %4.2f |" pred))
(format "| %4.2f |" pred))
((equal grouplens-prediction-display 'prediction-num)
- (fmt-prediction-num pred))
+ (bbb-fmt-prediction-num pred))
((equal grouplens-prediction-display 'confidence-plus-minus)
- (fmt-confidence-plus-minus pred low high))
+ (bbb-fmt-confidence-plus-minus pred low high))
(t
(gnus-message 3 "Invalid prediction display type")
(aset rate-string 11 ?|)
rate-string)))))
-(defun grouplens-valid-score (score)
+(defun bbb-valid-score (score)
(or (equal grouplens-prediction-display 'prediction-num)
(and (>= score grplens-minrating)
(<= score grplens-maxrating))))
-(defun requires-confidence (format-type)
+(defun bbb-requires-confidence (format-type)
(or (equal format-type 'confidence-plus-minus)
(equal format-type 'confidence-spot)
(equal format-type 'confidence-interval)))
-(defun have-confidence (clow chigh)
+(defun bbb-have-confidence (clow chigh)
(not (or (null clow)
(null chigh))))
-(defun fmt-prediction-spot (rate-string score)
+(defun bbb-fmt-prediction-spot (rate-string score)
(aset rate-string
- (round (* (/ (- score grplens-minrating) rating-range)
+ (round (* (/ (- score grplens-minrating) grplens-rating-range)
(+ (- grplens-predstringsize 4) 1.49)))
?*)
rate-string)
-(defun fmt-confidence-interval (score low high)
- (if (have-confidence low high)
+(defun bbb-fmt-confidence-interval (score low high)
+ (if (bbb-have-confidence low high)
(format "|%4.2f-%4.2f |" low high)
- (fmt-prediction-num score)))
+ (bbb-fmt-prediction-num score)))
-(defun fmt-confidence-plus-minus (score low high)
- (if (have-confidence low high)
+(defun bbb-fmt-confidence-plus-minus (score low high)
+ (if (bbb-have-confidence low high)
(format "|%3.1f+/-%4.2f|" score (/ (- high low) 2.0))
- (fmt-prediction-num score)))
+ (bbb-fmt-prediction-num score)))
-(defun fmt-prediction-bar (rate-string score)
+(defun bbb-fmt-prediction-bar (rate-string score)
(let* ((i 1)
- (step (/ rating-range (- grplens-predstringsize 4)))
+ (step (/ grplens-rating-range (- grplens-predstringsize 4)))
(half-step (/ step 2))
(loc (- grplens-minrating half-step)))
(while (< i (- grplens-predstringsize 2))
)
rate-string)
-(defun fmt-prediction-num (score)
+(defun bbb-fmt-prediction-num (score)
(format "| %4.2f |" score))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun bbb-summary-rate-article (rating &optional midin)
(interactive "nRating: ")
(when (member gnus-newsgroup-name grouplens-newsgroups)
- (let ((mid (or midin (get-current-id))))
+ (let ((mid (or midin (bbb-get-current-id))))
(if (and rating
(>= rating grplens-minrating)
(<= rating grplens-maxrating)
(gnus-set-mode-line 'summary))
-(defun get-current-id ()
+(defun bbb-get-current-id ()
(if gnus-current-headers
(aref gnus-current-headers
(nth 1 (assoc "message-id" gnus-header-index)))
(setq grouplens-current-starting-time (current-time)))
(defun grouplens-elapsed-time ()
- (let ((et (time-float (current-time))))
- (- et (time-float grouplens-current-starting-time))))
+ (let ((et (bbb-time-float (current-time))))
+ (- et (bbb-time-float grouplens-current-starting-time))))
-(defun time-float (timeval)
+(defun bbb-time-float (timeval)
(+ (* (car timeval) 65536)
(cadr timeval)))
grouplens-rating-alist)
(setcdr oldrating (cons (cadr oldrating) elapsed-time)))))
(grouplens-start-timer)
- (setq grouplens-previous-article (get-current-id))))
+ (setq grouplens-previous-article (bbb-get-current-id))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; BUG REPORTING
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defconst gnus-gl-version "gnus-gl.el 2.5lars/rrh")
+(defconst gnus-gl-version "gnus-gl.el 2.9")
(defconst gnus-gl-maintainer-address "grouplens-bug@cs.umn.edu")
(defun gnus-gl-submit-bug-report ()
"Submit via mail a bug report on gnus-gl"
(> (prefix-numeric-value arg) 0)))
(when gnus-grouplens-mode
(if (not (fboundp 'make-local-hook))
- (add-hook 'gnus-select-article-hook 'grouplens-do-time)
- (make-local-hook 'gnus-select-article-hook)
- (add-hook 'gnus-select-article-hook 'grouplens-do-time nil 'local))
+ (add-hook 'gnus-select-article-hook 'grouplens-do-time)
+ (make-local-hook 'gnus-select-article-hook)
+ (add-hook 'gnus-select-article-hook 'grouplens-do-time nil 'local))
(if (not (fboundp 'make-local-hook))
- (add-hook 'gnus-exit-group-hook 'bbb-put-ratings)
- (make-local-hook 'gnus-exit-group-hook)
- (add-hook 'gnus-exit-group-hook 'bbb-put-ratings nil 'local))
+ (add-hook 'gnus-exit-group-hook 'bbb-put-ratings)
+ (make-local-hook 'gnus-exit-group-hook)
+ (add-hook 'gnus-exit-group-hook 'bbb-put-ratings nil 'local))
(make-local-variable 'gnus-score-find-score-files-function)
(if gnus-grouplens-override-scoring
(setq gnus-score-find-score-files-function
(provide 'gnus-gl)
;;; end gnus-gl.el
+
(gnus-summary-select-article t)
;; Check whether the user owns the article that is to be superseded.
(unless (string-equal
- (downcase (mail-strip-quoted-names
+ (downcase (gnus-mail-strip-quoted-names
(mail-header-from gnus-current-headers)))
- (downcase (mail-strip-quoted-names (gnus-inews-user-name))))
+ (downcase (gnus-mail-strip-quoted-names (gnus-inews-user-name))))
(error "This article is not yours."))
;; Get a normal *Post News* buffer.
(gnus-new-news gnus-newsgroup-name t)
;; user id with value of its From: field.
(if (not
(string-equal
- (downcase (mail-strip-quoted-names from))
- (downcase (mail-strip-quoted-names (gnus-inews-user-name)))))
+ (downcase (gnus-mail-strip-quoted-names from))
+ (downcase (gnus-mail-strip-quoted-names
+ (gnus-inews-user-name)))))
(progn
(ding) (gnus-message 3 "This article is not yours.")
nil)
(string-match "<[^>]+>" gnus-warning))
(setq message-id (match-string 0 gnus-warning)))
- (setq mctdo (not (equal mct "never")))
+ (setq mctdo (and mct (not (equal mct "never"))))
(when (and mct (string= (downcase mct) "always"))
(setq mct (or reply-to from)))
new-cc
(if (and mctdo
(not (string=
- (mail-strip-quoted-names mct)
- (mail-strip-quoted-names
+ (gnus-mail-strip-quoted-names mct)
+ (gnus-mail-strip-quoted-names
(or to-address
(if (and follow-to
(not (stringp follow-to)))
(setq ccalist
(mapcar
(lambda (addr)
- (cons (mail-strip-quoted-names addr) addr))
+ (cons (gnus-mail-strip-quoted-names addr) addr))
(nreverse (gnus-mail-parse-comma-list))))
(let ((s ccalist))
(while s
;;; Treatment of rejected articles.
;;; Bounced mail.
+(defvar mail-unsent-separator)
+
(defun gnus-summary-resend-bounced-mail (fetch)
"Re-mail the current message.
This only makes sense if the current message is a bounce message than
If FETCH, try to fetch the article that this is a reply to, if indeed
this is a reply."
(interactive "P")
+ (require 'rmail)
(gnus-summary-select-article t)
;; Create a mail buffer.
(gnus-new-empty-mail)
(erase-buffer)
(insert-buffer-substring gnus-article-buffer)
(goto-char (point-min))
- (or (re-search-forward "--- *Original message.*\n" nil t)
+ (or (re-search-forward mail-unsent-separator nil t)
(and (search-forward "\n\n" nil t)
(re-search-forward "^Return-Path:.*\n" nil t)))
;; We remove everything before the bounced mail.
;; 1) display the icons in its own buffer:
;;
;; (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t)
-;; (add-hook 'gnus-summary-display-hook 'gnus-group-display-picons t)
+;; (add-hook 'gnus-summary-prepare-hook 'gnus-group-display-picons t)
;; (setq gnus-picons-display-where 'picons)
;;
;; Then add the picons buffer to your display configuration:
;; 2) display the icons in the summary buffer
;;
;; (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t)
-;; (add-hook 'gnus-summary-display-hook 'gnus-group-display-picons t)
+;; (add-hook 'gnus-summary-prepare-hook 'gnus-group-display-picons t)
;; (setq gnus-picons-display-where 'summary)
;;
;; 3) display the icons in the article buffer
;;
;; (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t)
-;; (add-hook 'gnus-article-display-hook 'gnus-group-display-picons t)
+;; (add-hook 'gnus-article-prepare-hook 'gnus-group-display-picons t)
;; (setq gnus-picons-display-where 'article)
;;
;;
'undefined 'gnus-tree-read-summary-keys gnus-tree-mode-map))
(defun gnus-tree-make-menu-bar ()
- )
+ (unless (boundp 'gnus-tree-menu)
+ (easy-menu-define
+ gnus-tree-menu gnus-tree-mode-map ""
+ '("Tree"))))
(defun gnus-tree-mode ()
"Major mode for displaying thread trees."
;; Find the "from".
(goto-char (point-min))
(setq from
- (mail-strip-quoted-names
+ (gnus-mail-strip-quoted-names
(or (mail-fetch-field "from")
(mail-fetch-field "really-from")
(mail-fetch-field "sender"))))
(gnus-delete-line))
unread))
-(defun gnus-topic-grok-active (&optional force)
+(defun gnus-topic-grok-active (&optional force read-active)
"Parse all active groups and create topic structures for them."
;; First we make sure that we have really read the active file.
(when (or force
(not gnus-topic-active-alist))
- (when (or force
- (not (member gnus-select-method gnus-have-read-active-file)))
+ (when (and read-active
+ (or force
+ (not (member gnus-select-method
+ gnus-have-read-active-file))))
(let ((gnus-read-active-file t))
(gnus-read-active-file)))
(let (topology groups alist)
"List all groups that Gnus knows about in a topicsified fashion.
If FORCE, always re-read the active file."
(interactive "P")
- (gnus-topic-grok-active)
+ (gnus-topic-grok-active force)
(let ((gnus-topic-topology gnus-topic-active-topology)
(gnus-topic-alist gnus-topic-active-alist)
gnus-killed-list gnus-zombie-list)
["List active file" gnus-group-list-active t])
("Sort"
["Default sort" gnus-group-sort-groups t]
- ["Sort by method" gnus-group-sort-by-method t]
- ["Sort by rank" gnus-group-sort-by-rank t]
- ["Sort by score" gnus-group-sort-by-score t]
- ["Sort by level" gnus-group-sort-by-level t]
- ["Sort by unread" gnus-group-sort-by-unread t]
- ["Sort by name" gnus-group-sort-by-alphabet t])
+ ["Sort by method" gnus-group-sort-groups-by-method t]
+ ["Sort by rank" gnus-group-sort-groups-by-rank t]
+ ["Sort by score" gnus-group-sort-groups-by-score t]
+ ["Sort by level" gnus-group-sort-groups-by-level t]
+ ["Sort by unread" gnus-group-sort-groups-by-unread t]
+ ["Sort by name" gnus-group-sort-groups-by-alphabet t])
("Mark"
["Mark group" gnus-group-mark-group t]
["Unmark group" gnus-group-unmark-group t]
"Move point to N buttons forward.
If N is negative, move backward instead."
(interactive "p")
- (let ((function (if (< n 0) 'prev-single-property-change
+ (let ((function (if (< n 0) 'previous-single-property-change
'next-single-property-change))
(inhibit-point-motion-hooks t)
(limit (if (< n 0) (point-min) (point-max))))
from to
(nconc (and gnus-article-mouse-face
(list gnus-mouse-face-prop gnus-article-mouse-face))
+ (list 'invisible nil)
(list 'gnus-callback fun)
(and data (list 'gnus-data data)))))
(gnus-eval-format
gnus-prev-page-line-format nil
`(gnus-prev t local-map ,gnus-prev-page-map
- gnus-callback gnus-article-prev-page))))
+ gnus-callback gnus-article-button-prev-page))))
(defvar gnus-next-page-map nil)
(unless gnus-next-page-map
(let ((buffer-read-only nil))
(gnus-eval-format gnus-next-page-line-format nil
`(gnus-next t local-map ,gnus-next-page-map
- gnus-callback gnus-article-prev-page))))
+ gnus-callback
+ gnus-article-button-next-page))))
+
+(defun gnus-article-button-next-page (arg)
+ "Go to the next page."
+ (interactive "P")
+ (let ((win (selected-window)))
+ (select-window (get-buffer-window gnus-article-buffer t))
+ (gnus-article-next-page)
+ (select-window win)))
+
+(defun gnus-article-button-prev-page (arg)
+ "Go to the prev page."
+ (interactive "P")
+ (let ((win (selected-window)))
+ (select-window (get-buffer-window gnus-article-buffer t))
+ (gnus-article-prev-page)
+ (select-window win)))
;;; Compatibility Functions:
(easy-menu-add gnus-article-article-menu)
(easy-menu-add gnus-article-treatment-menu))
+(defun gnus-xmas-pick-menu-add ()
+ (easy-menu-add gnus-pich-menu))
+
+(defun gnus-xmas-binary-menu-add ()
+ (easy-menu-add gnus-binary-menu))
+
+(defun gnus-xmas-tree-menu-add ()
+ (easy-menu-add gnus-tree-menu))
+
+(defun gnus-xmas-grouplens-menu-add ()
+ (easy-menu-add gnus-grouplens-menu))
+
(defun gnus-xmas-read-event-char ()
"Get the next event."
(let ((event (next-event)))
(fset 'gnus-tree-minimize 'gnus-xmas-tree-minimize)
(fset 'gnus-appt-select-lowest-window
'gnus-xmas-appt-select-lowest-window)
+ (fset 'gnus-mail-strip-quoted-names 'gnus-xmas-mail-strip-quoted-names)
(add-hook 'gnus-group-mode-hook 'gnus-xmas-group-menu-add)
(add-hook 'gnus-summary-mode-hook 'gnus-xmas-summary-menu-add)
(add-hook 'gnus-article-mode-hook 'gnus-xmas-article-menu-add)
+ (add-hook 'gnus-pick-mode-hook 'gnus-xmas-pick-menu-add)
+ (add-hook 'gnus-tree-mode-hook 'gnus-xmas-tree-menu-add)
+ (add-hook 'gnus-binary-mode-hook 'gnus-xmas-binary-menu-add)
+ (add-hook 'gnus-grouplens-mode-hook 'gnus-xmas-grouplens-menu-add)
+
(add-hook 'gnus-group-mode-hook 'gnus-xmas-setup-group-toolbar)
(add-hook 'gnus-summary-mode-hook 'gnus-xmas-setup-summary-toolbar))
(after-find-file error (not nowarn)))))
buf)))
+(defun gnus-xmas-mail-strip-quoted-names (address)
+ "Protect mail-strip-quoted-names from NIL input.
+XEmacs compatibility workaround."
+ (if (null address)
+ nil
+ (mail-strip-quoted-names address)))
;;; gnus-xmas.el ends here
;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
"gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
"The mail address of the Gnus maintainers.")
-(defconst gnus-version "September Gnus v0.48"
+(defconst gnus-version "September Gnus v0.49"
"Version number for this version of Gnus.")
(defvar gnus-info-nodes
gnus-cache-possibly-remove-articles gnus-cache-request-article
gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
gnus-cache-enter-remove-article gnus-cached-article-p
- gnus-cache-open gnus-cache-close)
+ gnus-cache-open gnus-cache-close gnus-cache-update-article)
("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
gnus-cache-remove-article)
("gnus-score" :interactive t
("gnus-edit" :interactive t gnus-score-customize)
("gnus-topic" :interactive t gnus-topic-mode)
("gnus-topic" gnus-topic-remove-group)
- ("gnus-salt" :interactive t gnus-pick-mode)
+ ("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
("gnus-uu" :interactive t
gnus-uu-digest-mail-forward gnus-uu-digest-post-forward
(setq params nil))
;; Create a new frame?
(unless (setq frame (elt gnus-frame-list i))
- (nconc gnus-frame-list (list (setq frame (make-frame params)))))
- (push frame gnus-created-frames)
+ (nconc gnus-frame-list (list (setq frame (make-frame params))))
+ (push frame gnus-created-frames))
;; Is the old frame still alive?
(unless (frame-live-p frame)
(setcar (nthcdr i gnus-frame-list)
(pop opened))
(caar opened))))
-(defmacro gnus-server-equal (ss1 ss2)
+(defmacro gnus-method-equal (ss1 ss2)
"Say whether two servers are equal."
`(let ((s1 ,ss1)
(s2 ,ss2))
(setq s1 (cdr s1)))
(null s1))))))
+(defun gnus-server-equal (m1 m2)
+ "Say whether two methods are equal."
+ (let ((m1 (cond ((null m1) gnus-select-method)
+ ((stringp m1) (gnus-server-to-method m1))
+ (t m1)))
+ (m2 (cond ((null m2) gnus-select-method)
+ ((stringp m2) (gnus-server-to-method m2))
+ (t m2))))
+ (gnus-method-equal m1 m2)))
+
(defun gnus-group-prefixed-name (group method)
"Return the whole name from GROUP and METHOD."
(and (stringp method) (setq method (gnus-server-to-method method)))
(if (and
(or (assoc (format "%s" (car method))
(gnus-methods-using 'address))
- (equal method gnus-message-archive-method))
+ (gnus-server-equal method gnus-message-archive-method))
+ (nth 1 method)
(not (string= (nth 1 method) "")))
(concat "+" (nth 1 method)))
":" group))
(or method-only-group (gnus-info-group info))
gnus-newsrc-hashtb))
(part-info info)
- (info (if method-only-group (nth 2 entry) info)))
+ (info (if method-only-group (nth 2 entry) info))
+ method)
(when method-only-group
(unless entry
(error "Trying to change non-existent group %s" method-only-group))
;; This is a new group, so we just create it.
(save-excursion
(set-buffer gnus-group-buffer)
- (if (gnus-info-method info)
+ (setq method (gnus-info-method info))
+ (when (gnus-server-equal method "native")
+ (setq method nil))
+ (if method
;; It's a foreign group...
(gnus-group-make-group
(gnus-group-real-name (gnus-info-group info))
- (prin1-to-string (car (gnus-info-method info)))
- (nth 1 (gnus-info-method info)))
+ (if (stringp method) method
+ (prin1-to-string (car method)))
+ (and (consp method)
+ (nth 1 (gnus-info-method info))))
;; It's a native group.
(gnus-group-make-group (gnus-info-group info)))
(gnus-message 6 "Note: New group created")
(progn
(setq info (gnus-copy-sequence info))
(setcar info new-group)
- (setcar (cddddr info) method)
+ (unless (gnus-server-equal method "native")
+ (unless (nthcdr 3 info)
+ (nconc info (list nil nil)))
+ (unless (nthcdr 4 info)
+ (nconc info (list nil)))
+ (gnus-info-set-method info method))
(gnus-group-set-info info))
(gnus-group-set-info form (or new-group group) part))
(kill-buffer (current-buffer))
(gnus-group-remove-mark group)
(setq level (gnus-group-group-level))
(gnus-delete-line)
- (if (and (not discard)
- (setq entry (gnus-gethash group gnus-newsrc-hashtb)))
- (setq gnus-list-of-killed-groups
- (cons (cons (car entry) (nth 2 entry))
- gnus-list-of-killed-groups)))
+ (when (and (not discard)
+ (setq entry (gnus-gethash group gnus-newsrc-hashtb)))
+ (push (cons (car entry) (nth 2 entry))
+ gnus-list-of-killed-groups))
(gnus-group-change-level
(if entry entry group) gnus-level-killed (if entry nil level)))
;; If there are lots and lots of groups to be killed, we use
(defun gnus-group-restart (&optional arg)
"Force Gnus to read the .newsrc file."
(interactive "P")
- (gnus-save-newsrc-file)
- (gnus-setup-news 'force)
- (gnus-group-list-groups arg))
+ (when (gnus-yes-or-no-p
+ (format "Are you sure you want to read %s? "
+ gnus-current-startup-file))
+ (gnus-save-newsrc-file)
+ (gnus-setup-news 'force)
+ (gnus-group-list-groups arg)))
(defun gnus-group-read-init-file ()
"Read the Gnus elisp init file."
(unread gnus-newsgroup-unreads)
(headers gnus-current-headers)
(data gnus-newsgroup-data)
+ (summary gnus-summary-buffer)
(article-buffer gnus-article-buffer)
(original gnus-original-article-buffer)
(score-file gnus-current-score-file))
(setq gnus-newsgroup-unreads unread)
(setq gnus-current-headers headers)
(setq gnus-newsgroup-data data)
+ (setq gnus-summary-buffer summary)
(setq gnus-article-buffer article-buffer)
(setq gnus-original-article-buffer original)
(setq gnus-current-score-file score-file)))))
(setq threads (cdr threads)))
result)))
-(defun gnus-summary-gather-threads-by-references (threads)
+(defun gnus-gather-threads-by-references (threads)
"Gather threads by looking at References headers."
(let ((idhashtb (gnus-make-hashtable 1023))
(thhashtb (gnus-make-hashtable 1023))
(setq buffer-read-only t)
(buffer-disable-undo (current-buffer))
(gnus-configure-windows 'summary)
- (gnus-summary-update-article (cdr gnus-article-current)))
+ (gnus-summary-update-article (cdr gnus-article-current))
+ (when gnus-use-cache
+ (gnus-cache-update-article
+ (cdr gnus-article-current) (car gnus-article-current))))
(run-hooks 'gnus-article-display-hook)
(and (gnus-visual-p 'summary-highlight 'highlight)
(run-hooks 'gnus-visual-mark-article-hook)))))
(gnus-set-global-variables)
(let ((backward (< n 0))
(n (abs n))
- old dum)
+ old dum int)
(while (and (> n 0)
- (setq old (save-excursion (forward-line 1) (point)))
- (gnus-summary-go-to-next-thread backward))
+ (setq old (save-excursion
+ (forward-line 1)
+ (setq int (gnus-summary-article-intangible-p))
+ (point)))
+ (or int
+ (gnus-summary-go-to-next-thread backward)))
(when (and (eq gnus-summary-make-false-root 'dummy)
(setq dum (text-property-not-all
old (point) 'gnus-intangible nil)))
(end-of-buffer
;; Long lines may cause an end-of-buffer error.
(goto-char (point-max))))
+ (move-to-window-line 0)
nil))
(defun gnus-article-prev-page (&optional lines)
(gnus-narrow-to-page -1) ;Go to previous page.
(goto-char (point-max))
(recenter -1))
- (condition-case ()
- (scroll-down lines)
- (error nil))))
+ (prog1
+ (condition-case ()
+ (scroll-down lines)
+ (error nil))
+ (move-to-window-line 0))))
(defun gnus-article-refer-article ()
"Read article specified by message-id around point."
(setq entry (gnus-gethash entry gnus-newsrc-hashtb)))
(if (and (not oldlevel)
(consp entry))
- (setq oldlevel (cadr (nth 2 entry))))
+ (setq oldlevel (gnus-info-level (nth 2 entry)))
+ (setq oldlevel 9))
(if (stringp previous)
(setq previous (gnus-gethash previous gnus-newsrc-hashtb)))
(defun gnus-get-unread-articles-in-group (info active &optional update)
(when active
;; Allow the backend to update the info in the group.
- (when update
- (gnus-request-update-info
- info (gnus-find-method-for-group (gnus-info-group info))))
+ (when (and update
+ (gnus-request-update-info
+ info (gnus-find-method-for-group (gnus-info-group info))))
+ (gnus-activate-group (gnus-info-group info)))
(let* ((range (gnus-info-read info))
(num 0)
(marked (gnus-info-marks info)))
;; If a cache is present, we may have to alter the active info.
- (and gnus-use-cache
- (gnus-cache-possibly-alter-active (gnus-info-group info) active))
+ (when (and gnus-use-cache info)
+ (gnus-cache-possibly-alter-active (gnus-info-group info) active))
;; Modify the list of read articles according to what articles
;; are available; then tally the unread articles and add the
;; number to the group hash table entry.
(setq range (cdr range)))
(setq num (max 0 (- (cdr active) num)))))
;; Set the number of unread articles.
- (setcar (gnus-gethash (gnus-info-group info) gnus-newsrc-hashtb) num)
+ (when info
+ (setcar (gnus-gethash (gnus-info-group info) gnus-newsrc-hashtb) num))
num)))
(defun gnus-activate-group (group &optional scan)
;; file (ticked articles, killed groups, foreign methods, etc.)
(gnus-read-newsrc-el-file quick-file)
- (if (or force
- (and (file-newer-than-file-p newsrc-file quick-file)
- (file-newer-than-file-p newsrc-file
- (concat quick-file "d")))
- (not gnus-newsrc-alist))
+ (if (and (file-exists-p gnus-current-startup-file)
+ (or force
+ (and (file-newer-than-file-p newsrc-file quick-file)
+ (file-newer-than-file-p newsrc-file
+ (concat quick-file "d")))
+ (not gnus-newsrc-alist)))
;; We read the .newsrc file. Note that if there if a
;; .newsrc.eld file exists, it has already been read, and
;; the `gnus-newsrc-hashtb' has been created. While reading
(1+ (point)) 'gnus-backlog nil (point-max)))))))
(defun gnus-backlog-request-article (group number buffer)
- (gnus-backlog-setup)
- (let ((ident (intern (concat group ":" (int-to-string number))
- gnus-backlog-hashtb))
- beg end)
- (when (memq ident gnus-backlog-articles)
- ;; It was in the backlog.
- (save-excursion
- (set-buffer (gnus-backlog-buffer))
- (if (not (setq beg (text-property-any
- (point-min) (point-max) 'gnus-backlog
- ident)))
- ;; It wasn't in the backlog after all.
- (ignore
- (setq gnus-backlog-articles (delq ident gnus-backlog-articles)))
- ;; Find the end (i. e., the beginning of the next article).
- (setq end
- (next-single-property-change
- (1+ beg) 'gnus-backlog (current-buffer) (point-max)))))
- (let ((buffer-read-only nil))
- (erase-buffer)
- (insert-buffer-substring gnus-backlog-buffer beg end)
- t))))
+ (when (numberp number)
+ (gnus-backlog-setup)
+ (let ((ident (intern (concat group ":" (int-to-string number))
+ gnus-backlog-hashtb))
+ beg end)
+ (when (memq ident gnus-backlog-articles)
+ ;; It was in the backlog.
+ (save-excursion
+ (set-buffer (gnus-backlog-buffer))
+ (if (not (setq beg (text-property-any
+ (point-min) (point-max) 'gnus-backlog
+ ident)))
+ ;; It wasn't in the backlog after all.
+ (ignore
+ (setq gnus-backlog-articles (delq ident gnus-backlog-articles)))
+ ;; Find the end (i. e., the beginning of the next article).
+ (setq end
+ (next-single-property-change
+ (1+ beg) 'gnus-backlog (current-buffer) (point-max)))))
+ (let ((buffer-read-only nil))
+ (erase-buffer)
+ (insert-buffer-substring gnus-backlog-buffer beg end)
+ t)))))
;; Allow redefinition of Gnus functions.
(narrow-to-region (car entry) (nth 3 entry))
(goto-char (point-min))
(when (looking-at " *\\*\\(.*\\)$")
- (setq subject (match-string 1)))
+ (setq subject (match-string 1))
+ (when (string-match "[ \t]+$" subject)
+ (setq subject (substring subject 0 (match-beginning 0)))))
(when
(let ((case-fold-search nil))
(re-search-forward
(defun nndraft-request-update-info (group info &optional server)
(setcar (cddr info) nil)
(when (nth 3 info)
- (setcar (nthcdr 3 info) nil)))
+ (setcar (nthcdr 3 info) nil))
+ t)
(defun nndraft-request-associate-buffer (group)
"Associate the current buffer with some article in the draft group."
(defun nnvirtual-create-mapping ()
"Create an article mapping for the current group."
- (let* (div m marks article list
+ (let* (div m marks list article
(map (sort
(apply
'nconc
+Fri Mar 1 20:52:50 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (Customizing Threading): Change.
+
Wed Feb 28 04:54:41 1996 Lars Ingebrigtsen <lars@eyesore.no>
* gnus.texi (Slow Terminal Connection): Addition.
cholera:
@table @code
-@item gnus-summary-gather-threads-by-subject
-@findex gnus-summary-gather-threads-by-subject
+@item gnus-gather-threads-by-subject
+@findex gnus-gather-threads-by-subject
This function is the default gathering function and looks at
@code{Subject}s exclusively.
-@item gnus-summary-gather-threads-by-references
-@findex gnus-summary-gather-threads-by-references
+@item gnus-gather-threads-by-references
+@findex gnus-gather-threads-by-references
This function looks at @code{References} headers exclusively.
@end table
@lisp
(setq gnus-summary-thread-gathering-function
- 'gnus-summary-gather-threads-by-references)
+ 'gnus-gather-threads-by-references)
@end lisp
@item gnus-summary-make-false-root
If you set @code{gnus-keep-backlog} to a number @var{n}, Gnus will store
at most @var{n} old articles in a buffer for later re-fetching. If this
variable is non-@code{nil} and is not a number, Gnus will store
-@emph{all} read articles, which means that your Emacs will group without
+@emph{all} read articles, which means that your Emacs will grow without
bound before exploding and taking your machine down with you. I put
that in there just to keep y'all on your toes.
projects / gnus / commitdiff