'("^Path:" "^Posting-Version:" "^Article-I.D.:" "^Expires:"
"^Date-Received:" "^References:" "^Control:" "^Xref:" "^Lines:"
"^Posted:" "^Relay-Version:" "^Message-ID:" "^Nf-ID:" "^Nf-From:"
- "^Approved:" "^Sender:" "^Received:" "^Mail-from:")
+ "^Approved:" "^Sender:" "^Received:" "^Mail-from:")
"All headers that match this regexp will be hidden.
This variable can also be a list of regexps of headers to be ignored.
If `gnus-visible-headers' is non-nil, this variable will be ignored."
(repeat regexp))
:group 'gnus-article-hiding)
-(defcustom gnus-visible-headers
+(defcustom gnus-visible-headers
"^From:\\|^Newsgroups:\\|^Subject:\\|^Date:\\|^Followup-To:\\|^Reply-To:\\|^Organization:\\|^Summary:\\|^Keywords:\\|^To:\\|^Cc:\\|^Posted-To:\\|^Mail-Copies-To:\\|^Apparently-To:\\|^Gnus-Warning:\\|^Resent-From"
"All headers that do not match this regexp will be hidden.
This variable can also be a list of regexp of headers to remain visible.
(defcustom gnus-hidden-properties '(invisible t intangible t)
"Property list to use for hiding text."
- :type 'sexp
+ :type 'sexp
:group 'gnus-article-hiding)
(defcustom gnus-article-x-face-command
"Face used for displaying bold italic emphasized text (/*word*/)."
:group 'gnus-article-emphasis)
-(defface gnus-emphasis-underline-bold-italic
+(defface gnus-emphasis-underline-bold-italic
'((t (:bold t :italic t :underline t)))
"Face used for displaying underlined bold italic emphasized text.
Esample: (_/*word*/_)."
(autoload 'timezone-make-date-arpa-standard "timezone")
(autoload 'mail-extract-address-components "mail-extr"))
-(defcustom gnus-article-save-directory gnus-directory
- "*Name of the directory articles will be saved in (default \"~/News\")."
- :group 'gnus-article-saving
- :type 'directory)
-
(defcustom gnus-save-all-headers t
"*If non-nil, don't remove any headers before saving."
:group 'gnus-article-saving
:group 'gnus-article-highlight
:group 'gnus-article-signature)
-(defface gnus-header-from-face
+(defface gnus-header-from-face
'((((class color)
(background dark))
- (:foreground "light blue" :bold t :italic t))
+ (:foreground "spring green" :bold t))
(((class color)
(background light))
- (:foreground "MidnightBlue" :bold t :italic t))
- (t
+ (:foreground "red3" :bold t))
+ (t
(:bold t :italic t)))
"Face used for displaying from headers."
:group 'gnus-article-headers
:group 'gnus-article-highlight)
-(defface gnus-header-subject-face
+(defface gnus-header-subject-face
'((((class color)
(background dark))
- (:foreground "pink" :bold t :italic t))
+ (:foreground "SeaGreen3" :bold t))
(((class color)
(background light))
- (:foreground "firebrick" :bold t :italic t))
- (t
+ (:foreground "red4" :bold t))
+ (t
(:bold t :italic t)))
"Face used for displaying subject headers."
:group 'gnus-article-headers
:group 'gnus-article-highlight)
-(defface gnus-header-newsgroups-face
+(defface gnus-header-newsgroups-face
'((((class color)
(background dark))
(:foreground "yellow" :bold t :italic t))
(((class color)
(background light))
- (:foreground "indianred" :bold t :italic t))
- (t
+ (:foreground "MidnightBlue" :bold t :italic t))
+ (t
(:bold t :italic t)))
"Face used for displaying newsgroups headers."
:group 'gnus-article-headers
:group 'gnus-article-highlight)
-(defface gnus-header-name-face
+(defface gnus-header-name-face
'((((class color)
(background dark))
- (:foreground "cyan" :bold t))
+ (:foreground "SeaGreen"))
(((class color)
(background light))
- (:foreground "DarkGreen" :bold t))
- (t
+ (:foreground "maroon"))
+ (t
(:bold t)))
"Face used for displaying header names."
:group 'gnus-article-headers
(:foreground "forest green" :italic t))
(((class color)
(background light))
- (:foreground "DarkGreen" :italic t))
- (t
+ (:foreground "indianred4" :italic t))
+ (t
(:italic t))) "Face used for displaying header content."
:group 'gnus-article-headers
:group 'gnus-article-highlight)
("" gnus-header-name-face gnus-header-content-face))
"Controls highlighting of article header.
-An alist of the form (HEADER NAME CONTENT).
+An alist of the form (HEADER NAME CONTENT).
HEADER is a regular expression which should match the name of an
header header and NAME and CONTENT are either face names or nil.
(defvar gnus-article-mode-syntax-table
(let ((table (copy-syntax-table text-mode-syntax-table)))
- ;;(modify-syntax-entry ?_ "w" table)
+ (modify-syntax-entry ?- "w" table)
table)
"Syntax table used in article mode buffers.
Initialized from `text-mode-syntax-table.")
"Set text PROPS on the B to E region, extending `intangible' 1 past B."
(add-text-properties b e props)
(when (memq 'intangible props)
- (put-text-property
+ (put-text-property
(max (1- b) (point-min))
b 'intangible (cddr (memq 'intangible props)))))
(while (re-search-forward "^[^ \t]*:" nil t)
(beginning-of-line)
;; Mark the rank of the header.
- (put-text-property
+ (put-text-property
(point) (1+ (point)) 'message-rank
(if (or (and visible (looking-at visible))
(and ignored
(not (looking-at ignored))))
- (gnus-article-header-rank)
+ (gnus-article-header-rank)
(+ 2 max)))
(forward-line 1))
(message-sort-headers-1)
- (when (setq beg (text-property-any
+ (when (setq beg (text-property-any
(point-min) (point-max) 'message-rank (+ 2 max)))
;; We make the unwanted headers invisible.
(if delete
(forward-line -1)
(gnus-article-hide-text-type
(progn (beginning-of-line) (point))
- (progn
+ (progn
(end-of-line)
(if (re-search-forward "^[^ \t]" nil t)
(match-beginning 0)
(when (and
from reply-to
(ignore-errors
- (equal
+ (equal
(nth 1 (mail-extract-address-components from))
(nth 1 (mail-extract-address-components reply-to)))))
(gnus-article-hide-header "reply-to"))))
(when (re-search-forward (concat "^" header ":") nil t)
(gnus-article-hide-text-type
(progn (beginning-of-line) (point))
- (progn
+ (progn
(end-of-line)
(if (re-search-forward "^[^ \t]" nil t)
(match-beginning 0)
;; We do the boldification/underlining by hiding the
;; overstrikes and putting the proper text property
;; on the letters.
- (cond
+ (cond
((eq next previous)
(gnus-article-hide-text-type (- (point) 2) (point) 'overstrike)
(put-text-property (point) (1+ (point)) 'face 'bold))
(goto-char (point-min))
(or (search-forward "\n\n" nil t) (point-max)))
(goto-char (point-min))
- (while (re-search-forward
+ (while (re-search-forward
"=\\?iso-8859-1\\?q\\?\\([^?\t\n]*\\)\\?=" nil t)
(setq string (match-string 1))
(save-restriction
(narrow-to-region (match-beginning 0) (match-end 0))
(delete-region (point-min) (point-max))
(insert string)
- (article-mime-decode-quoted-printable
+ (article-mime-decode-quoted-printable
(goto-char (point-min)) (point-max))
(subst-char-in-region (point-min) (point-max) ?_ ? )
(goto-char (point-max)))
(defun article-mime-decode-quoted-printable-buffer ()
"Decode Quoted-Printable in the current buffer."
(article-mime-decode-quoted-printable (point-min) (point-max)))
-
+
(defun article-mime-decode-quoted-printable (from to)
"Decode Quoted-Printable in the region between FROM and TO."
(interactive "r")
(goto-char (point-min))
;; Hide the "header".
(when (search-forward "\n-----BEGIN PGP SIGNED MESSAGE-----\n" nil t)
- (gnus-article-hide-text-type (match-beginning 0) (match-end 0) 'pgp))
+ (gnus-article-hide-text-type (1+ (match-beginning 0))
+ (match-end 0) 'pgp))
(setq beg (point))
;; Hide the actual signature.
(and (search-forward "\n-----BEGIN PGP SIGNATURE-----\n" nil t)
(narrow-to-region beg end)
(goto-char (point-min))
(while (re-search-forward "^- " nil t)
- (gnus-article-hide-text-type
+ (gnus-article-hide-text-type
(match-beginning 0) (match-end 0) 'pgp))
(widen))))))
(save-restriction
(let ((buffer-read-only nil))
(when (gnus-article-narrow-to-signature)
- (gnus-article-hide-text-type
+ (gnus-article-hide-text-type
(point-min) (point-max) 'signature)))))))
(defun article-strip-leading-blank-lines ()
"Replace consecutive blank lines with one empty line."
(interactive)
(save-excursion
- (let (buffer-read-only)
+ (let ((inhibit-point-motion-hooks t)
+ buffer-read-only)
;; First make all blank lines empty.
(goto-char (point-min))
+ (search-forward "\n\n" nil t)
(while (re-search-forward "^[ \t]+$" nil t)
(replace-match "" nil t))
;; Then replace multiple empty lines with a single empty line.
(goto-char (point-min))
+ (search-forward "\n\n" nil t)
(while (re-search-forward "\n\n\n+" nil t)
(replace-match "\n\n" t t)))))
+(defun article-strip-leading-space ()
+ "Remove all white space from the beginning of the lines in the article."
+ (interactive)
+ (save-excursion
+ (let ((inhibit-point-motion-hooks t)
+ buffer-read-only)
+ (goto-char (point-min))
+ (search-forward "\n\n" nil t)
+ (while (re-search-forward "^[ \t]+" nil t)
+ (replace-match "" t t)))))
+
(defun article-strip-blank-lines ()
"Strip leading, trailing and multiple blank lines."
(interactive)
(narrow-to-region
(funcall (intern "mime::preview-content-info/point-min") pcinfo)
(point-max)))))
-
+
(when (gnus-article-search-signature)
(forward-line 1)
;; Check whether we have some limits to what we consider
(goto-char cur)
nil)))
+(eval-and-compile
+ (autoload 'w3-parse-buffer "w3-parse"))
+
+(defun gnus-article-treat-html ()
+ "Render HTML."
+ (interactive)
+ (let ((cbuf (current-buffer)))
+ (set-buffer gnus-article-buffer)
+ (let (buf buffer-read-only b e)
+ (goto-char (point-min))
+ (narrow-to-region
+ (if (search-forward "\n\n" nil t)
+ (setq b (point))
+ (point-max))
+ (setq e (point-max)))
+ (nnheader-temp-write nil
+ (insert-buffer-substring gnus-article-buffer b e)
+ (save-window-excursion
+ (setq buf (car (w3-parse-buffer (current-buffer))))))
+ (when buf
+ (delete-region (point-min) (point-max))
+ (insert-buffer-substring buf)
+ (kill-buffer buf))
+ (widen)
+ (goto-char (point-min))
+ (set-window-start (get-buffer-window (current-buffer)) (point-min))
+ (set-buffer cbuf))))
+
(defun gnus-article-hidden-arg ()
"Return the current prefix arg as a number, or 0 if no prefix."
(list (if current-prefix-arg
If TYPE is `local', convert to local time; if it is `lapsed', output
how much time has lapsed since DATE."
(interactive (list 'ut t))
- (let* ((header (or header
+ (let* ((header (or header
(mail-header-date gnus-current-headers)
(message-fetch-field "date")
""))
(concat "Date: " date "\n"))
;; Let the user define the format.
((eq type 'user)
- (format-time-string gnus-article-time-format
- (ignore-errors
- (gnus-encode-date
- (timezone-make-date-arpa-standard
- date nil "UT")))))
+ (concat
+ "Date: "
+ (format-time-string gnus-article-time-format
+ (ignore-errors
+ (gnus-encode-date
+ (timezone-make-date-arpa-standard
+ date nil "UT"))))
+ "\n"))
;; Do an X-Sent lapsed format.
((eq type 'lapsed)
;; If the date is seriously mangled, the timezone functions are
(prog1
(concat (if prev ", " "") (int-to-string
(floor num))
- " " (symbol-name (car unit))
+ " " (symbol-name (car unit))
(if (> num 1) "s" ""))
(setq prev t))))
article-time-units "")
(article-date-ut 'lapsed highlight))
(defun article-date-user (&optional highlight)
- "Convert the current article date to the user-defined format."
+ "Convert the current article date to the user-defined format.
+This format is defined by the `gnus-article-time-format' variable."
(interactive (list t))
(article-date-ut 'user highlight))
(when (eq gnus-prompt-before-saving t)
num))) ; Magic
(set-buffer gnus-summary-buffer)
- (funcall gnus-default-article-saver filename)))))
+ (funcall gnus-default-article-saver filename)))))
(defun gnus-read-save-file-name (prompt default-name &optional filename)
(cond
(save-excursion
(save-restriction
(widen)
- (if (and (file-readable-p filename) (mail-file-babyl-p filename))
- (gnus-output-to-rmail filename)
- (let ((mail-use-rfc822 t))
- (rmail-output filename 1 t t))))))
+ (if (and (file-readable-p filename)
+ (mail-file-babyl-p filename))
+ (gnus-output-to-rmail filename t)
+ (gnus-output-to-mail filename)))))
;; Remember the directory name to save articles.
(setq gnus-newsgroup-last-mail filename)))
(cond ((eq command 'default)
gnus-last-shell-command)
(command command)
- (t (read-string
+ (t (read-string
(format
"Shell command on %s: "
(if (and gnus-number-of-articles-to-be-saved
gfunc (cdr func))
(setq afunc func
gfunc (intern (format "gnus-%s" func))))
- (fset gfunc
+ (fset gfunc
(if (not (fboundp afunc))
nil
`(lambda (&optional interactive &rest args)
article-remove-trailing-blank-lines
article-strip-leading-blank-lines
article-strip-multiple-blank-lines
+ article-strip-leading-space
article-strip-blank-lines
article-date-local
article-date-original
["Remove carriage return" gnus-article-remove-cr t]
["Remove quoted-unreadable" gnus-article-de-quoted-unreadable t]))
- (when (boundp 'gnus-summary-article-menu)
- (define-key gnus-article-mode-map [menu-bar commands]
- (cons "Commands" gnus-summary-article-menu)))
+ (when nil
+ (when (boundp 'gnus-summary-article-menu)
+ (define-key gnus-article-mode-map [menu-bar commands]
+ (cons "Commands" gnus-summary-article-menu))))
(when (boundp 'gnus-summary-post-menu)
(define-key gnus-article-mode-map [menu-bar post]
(use-local-map gnus-article-mode-map)
(gnus-update-format-specifications nil 'article-mode)
(set (make-local-variable 'page-delimiter) gnus-page-delimiter)
+ (set (make-local-variable 'gnus-button-marker-list) nil)
(gnus-set-default-directory)
(buffer-disable-undo (current-buffer))
(setq buffer-read-only t)
;;; Article savers.
-(defun gnus-output-to-rmail (file-name)
- "Append the current article to an Rmail file named FILE-NAME."
- (require 'rmail)
- ;; Most of these codes are borrowed from rmailout.el.
- (setq file-name (expand-file-name file-name))
- (setq rmail-default-rmail-file file-name)
- (let ((artbuf (current-buffer))
- (tmpbuf (get-buffer-create " *Gnus-output*")))
- (save-excursion
- (or (get-file-buffer file-name)
- (file-exists-p file-name)
- (if (gnus-yes-or-no-p
- (concat "\"" file-name "\" does not exist, create it? "))
- (let ((file-buffer (create-file-buffer file-name)))
- (save-excursion
- (set-buffer file-buffer)
- (rmail-insert-rmail-file-header)
- (let ((require-final-newline nil))
- (gnus-write-buffer file-name)))
- (kill-buffer file-buffer))
- (error "Output file does not exist")))
- (set-buffer tmpbuf)
- (buffer-disable-undo (current-buffer))
- (erase-buffer)
- (insert-buffer-substring artbuf)
- (gnus-convert-article-to-rmail)
- ;; Decide whether to append to a file or to an Emacs buffer.
- (let ((outbuf (get-file-buffer file-name)))
- (if (not outbuf)
- (append-to-file (point-min) (point-max) file-name)
- ;; File has been visited, in buffer OUTBUF.
- (set-buffer outbuf)
- (let ((buffer-read-only nil)
- (msg (and (boundp 'rmail-current-message)
- (symbol-value 'rmail-current-message))))
- ;; If MSG is non-nil, buffer is in RMAIL mode.
- (when msg
- (widen)
- (narrow-to-region (point-max) (point-max)))
- (insert-buffer-substring tmpbuf)
- (when msg
- (goto-char (point-min))
- (widen)
- (search-backward "\^_")
- (narrow-to-region (point) (point-max))
- (goto-char (1+ (point-min)))
- (rmail-count-new-messages t)
- (rmail-show-message msg))))))
- (kill-buffer tmpbuf)))
-
(defun gnus-output-to-file (file-name)
"Append the current article to a file named FILE-NAME."
(let ((artbuf (current-buffer)))
(insert "\n")
(append-to-file (point-min) (point-max) file-name))))
-(defun gnus-convert-article-to-rmail ()
- "Convert article in current buffer to Rmail message format."
- (let ((buffer-read-only nil))
- ;; Convert article directly into Babyl format.
- ;; Suggested by Rob Austein <sra@lcs.mit.edu>
- (goto-char (point-min))
- (insert "\^L\n0, unseen,,\n*** EOOH ***\n")
- (while (search-forward "\n\^_" nil t) ;single char
- (replace-match "\n^_" t t)) ;2 chars: "^" and "_"
- (goto-char (point-max))
- (insert "\^_")))
-
(defun gnus-narrow-to-page (&optional arg)
"Narrow the article buffer to a page.
If given a numerical ARG, move forward ARG pages."
"Show the next page of the article."
(interactive)
(when (gnus-article-next-page)
+ (goto-char (point-min))
(gnus-article-read-summary-keys nil (gnus-character-to-event ?n))))
(defun gnus-article-goto-prev-page ()
(recenter -1))
(let ((scroll-in-place nil))
(prog1
- (ignore-errors
- (scroll-down lines))
+ (condition-case ()
+ (scroll-down lines)
+ (beginning-of-buffer
+ (goto-char (point-min))))
(move-to-window-line 0)))))
(defun gnus-article-refer-article ()
(set-buffer gnus-summary-buffer)
(let ((header (gnus-summary-article-header article)))
(when (< article 0)
- (cond
+ (cond
((memq article gnus-newsgroup-sparse)
;; This is a sparse gap article.
(setq do-update-line article)
;; It is an extracted pseudo-article.
(setq article 'pseudo)
(gnus-request-pseudo-article header))))
-
- (let ((method (gnus-find-method-for-group
+
+ (let ((method (gnus-find-method-for-group
gnus-newsgroup-name)))
(if (not (eq (car method) 'nneething))
()
(when (numberp article)
(gnus-async-prefetch-next group article gnus-summary-buffer)
(when gnus-keep-backlog
- (gnus-backlog-enter-article
+ (gnus-backlog-enter-article
group article (current-buffer))))
'article)))
;; It was a pseudo.
(erase-buffer)
(insert-buffer-substring gnus-article-buffer))
(setq gnus-original-article (cons group article))))
-
+
;; Update sparse articles.
(when (and do-update-line
(or (numberp article)
(defvar gnus-article-edit-mode-map nil)
-(unless gnus-article-edit-mode-map
+(unless gnus-article-edit-mode-map
(setq gnus-article-edit-mode-map (copy-keymap text-mode-map))
(gnus-define-keys gnus-article-edit-mode-map
(gnus-article-mode)
;; The cache and backlog have to be flushed somewhat.
(when gnus-use-cache
- (gnus-cache-update-article
+ (gnus-cache-update-article
(car gnus-article-current) (cdr gnus-article-current)))
(when gnus-keep-backlog
- (gnus-backlog-remove-article
+ (gnus-backlog-remove-article
(car gnus-article-current) (cdr gnus-article-current)))
;; Flush original article as well.
(save-excursion
(set-window-start (get-buffer-window (current-buffer)) window-start)
(goto-char p)
(set-buffer buf)))))
-
+
(defun gnus-article-edit-full-stops ()
"Interactively repair spacing at end of sentences."
(interactive)
(let ((case-fold-search nil))
(query-replace-regexp "\\([.!?][])}]* \\)\\([[({A-Z]\\)" "\\1 \\2"))))
-;;;
+;;;
;;; Article highlights
;;;
:group 'gnus-article-buttons
:type 'regexp)
-(defcustom gnus-button-alist
- `(("\\(\\b<?\\(url: ?\\)?news:\\([^>\n\t ]*\\)>?\\)" 1 t
- gnus-button-message-id 3)
- ("\\(\\b<?\\(url: ?\\)?news:\\(//\\)?\\([^>\n\t ]*\\)>?\\)" 1 t
+(defcustom gnus-button-alist
+ `(("<\\(url: ?\\)?news:\\([^>\n\t ]*@[^>\n\t ]*\\)>" 0 t
+ gnus-button-message-id 2)
+ ("\\bnews:\\([^>\n\t ]*@[^>\n\t ]*+\\)" 0 t gnus-button-message-id 1)
+ ("\\(\\b<\\(url: ?\\)?news:\\(//\\)?\\([^>\n\t ]*\\)>\\)" 1 t
gnus-button-fetch-group 4)
- ("\\bin\\( +article\\)? +\\(<\\([^\n @<>]+@[^\n @<>]+\\)>\\)" 2
+ ("\\bnews:\\(//\\)?\\([^>\n\t ]+\\)" 0 t gnus-button-fetch-group 2)
+ ("\\bin\\( +article\\)? +\\(<\\([^\n @<>]+@[^\n @<>]+\\)>\\)" 2
t gnus-button-message-id 3)
- ("\\(<URL: *\\)?mailto: *\\([^> \n\t]+\\)>?" 0 t gnus-url-mailto 2)
+ ("\\(<URL: *\\)mailto: *\\([^> \n\t]+\\)>" 0 t gnus-url-mailto 1)
+ ("\\bmailto:\\([^ \n\t]+\\)" 0 t gnus-url-mailto 2)
;; This is how URLs _should_ be embedded in text...
("<URL: *\\([^>]*\\)>" 0 t gnus-button-embedded-url 1)
;; Raw URLs.
REGEXP: is the string matching text around the button,
BUTTON: is the number of the regexp grouping actually matching the button,
FORM: is a lisp expression which must eval to true for the button to
-be added,
+be added,
CALLBACK: is the function to call when the user push this button, and each
PAR: is a number of a regexp grouping whose text will be passed to CALLBACK.
CALLBACK can also be a variable, in that case the value of that
variable it the real callback function."
:group 'gnus-article-buttons
- :type '(repeat (list regexp
+ :type '(repeat (list regexp
(integer :tag "Button")
(sexp :tag "Form")
(function :tag "Callback")
:inline t
(integer :tag "Regexp group")))))
-(defcustom gnus-header-button-alist
+(defcustom gnus-header-button-alist
`(("^\\(References\\|Message-I[Dd]\\):" "<[^>]+>"
0 t gnus-button-message-id 0)
("^\\(From\\|Reply-To\\):" ": *\\(.+\\)$" 1 t gnus-button-reply 1)
- ("^\\(Cc\\|To\\):" "[^ \t\n<>,()\"]+@[^ \t\n<>,()\"]+"
+ ("^\\(Cc\\|To\\):" "[^ \t\n<>,()\"]+@[^ \t\n<>,()\"]+"
0 t gnus-button-mailto 0)
("^X-[Uu][Rr][Ll]:" ,gnus-button-url-regexp 0 t gnus-button-url 0)
("^[^:]+:" ,gnus-button-url-regexp 0 t gnus-button-url 0)
:group 'gnus-article-buttons
:group 'gnus-article-headers
:type '(repeat (list (regexp :tag "Header")
- regexp
+ regexp
(integer :tag "Button")
(sexp :tag "Form")
(function :tag "Callback")
(defun gnus-article-highlight (&optional force)
"Highlight current article.
This function calls `gnus-article-highlight-headers',
-`gnus-article-highlight-citation',
+`gnus-article-highlight-citation',
`gnus-article-highlight-signature', and `gnus-article-add-buttons' to
do the highlighting. See the documentation for those functions."
(interactive (list 'force))
(case-fold-search t)
(inhibit-point-motion-hooks t)
entry regexp header-face field-face from hpoints fpoints)
- (goto-char (point-min))
- (when (search-forward "\n\n" nil t)
- (narrow-to-region (1- (point)) (point-min))
- (while (setq entry (pop alist))
- (goto-char (point-min))
- (setq regexp (concat "^\\("
- (if (string-equal "" (nth 0 entry))
- "[^\t ]"
- (nth 0 entry))
- "\\)")
- header-face (nth 1 entry)
- field-face (nth 2 entry))
- (while (and (re-search-forward regexp nil t)
- (not (eobp)))
- (beginning-of-line)
- (setq from (point))
- (unless (search-forward ":" nil t)
- (forward-char 1))
- (when (and header-face
- (not (memq (point) hpoints)))
- (push (point) hpoints)
- (gnus-put-text-property from (point) 'face header-face))
- (when (and field-face
- (not (memq (setq from (point)) fpoints)))
- (push from fpoints)
- (if (re-search-forward "^[^ \t]" nil t)
- (forward-char -2)
- (goto-char (point-max)))
- (gnus-put-text-property from (point) 'face field-face)))))))))
+ (message-narrow-to-head)
+ (while (setq entry (pop alist))
+ (goto-char (point-min))
+ (setq regexp (concat "^\\("
+ (if (string-equal "" (nth 0 entry))
+ "[^\t ]"
+ (nth 0 entry))
+ "\\)")
+ header-face (nth 1 entry)
+ field-face (nth 2 entry))
+ (while (and (re-search-forward regexp nil t)
+ (not (eobp)))
+ (beginning-of-line)
+ (setq from (point))
+ (unless (search-forward ":" nil t)
+ (forward-char 1))
+ (when (and header-face
+ (not (memq (point) hpoints)))
+ (push (point) hpoints)
+ (gnus-put-text-property from (point) 'face header-face))
+ (when (and field-face
+ (not (memq (setq from (point)) fpoints)))
+ (push from fpoints)
+ (if (re-search-forward "^[^ \t]" nil t)
+ (forward-char -2)
+ (goto-char (point-max)))
+ (gnus-put-text-property from (point) 'face field-face))))))))
(defun gnus-article-highlight-signature ()
"Highlight the signature in an article.
It does this by highlighting everything after
-`gnus-signature-separator' using `gnus-signature-face'."
+`gnus-signature-separator' using `gnus-signature-face'."
(interactive)
(save-excursion
(set-buffer gnus-article-buffer)
(gnus-article-add-button start (1- end) 'gnus-signature-toggle
end)))))))
+(defun gnus-button-in-region-p (b e prop)
+ "Say whether PROP exists in the region."
+ (text-property-not-all b e prop nil))
+
(defun gnus-article-add-buttons (&optional force)
"Find external references in the article and make buttons of them.
\"External references\" are things like Message-IDs and URLs, as
(interactive (list 'force))
(save-excursion
(set-buffer gnus-article-buffer)
- ;; Remove all old markers.
- (while gnus-button-marker-list
- (set-marker (pop gnus-button-marker-list) nil))
(let ((buffer-read-only nil)
(inhibit-point-motion-hooks t)
(case-fold-search t)
(alist gnus-button-alist)
beg entry regexp)
- (goto-char (point-min))
+ ;; Remove all old markers.
+ (let (marker entry)
+ (while (setq marker (pop gnus-button-marker-list))
+ (goto-char marker)
+ (when (setq entry (gnus-button-entry))
+ (put-text-property (match-beginning (nth 1 entry))
+ (match-end (nth 1 entry))
+ 'gnus-callback nil))
+ (set-marker marker nil)))
;; We skip the headers.
+ (goto-char (point-min))
(unless (search-forward "\n\n" nil t)
(goto-char (point-max)))
(setq beg (point))
(from (match-beginning 0)))
(when (and (or (eq t (nth 1 entry))
(eval (nth 1 entry)))
- (not (get-text-property (point) 'gnus-callback)))
+ (not (gnus-button-in-region-p
+ start end 'gnus-callback)))
;; That optional form returned non-nil, so we add the
- ;; button.
- (gnus-article-add-button
- start end 'gnus-button-push
+ ;; button.
+ (gnus-article-add-button
+ start end 'gnus-button-push
(car (push (set-marker (make-marker) from)
gnus-button-marker-list))))))))))
(form (nth 2 entry)))
(goto-char (match-end 0))
(when (eval form)
- (gnus-article-add-button
+ (gnus-article-add-button
start end (nth 3 entry)
(buffer-substring (match-beginning (nth 4 entry))
(match-end (nth 4 entry)))))))
(when gnus-article-button-face
(gnus-overlay-put (gnus-make-overlay from to)
'face gnus-article-button-face))
- (gnus-add-text-properties
+ (gnus-add-text-properties
from to
(nconc (and gnus-article-mouse-face
(list gnus-mouse-face-prop gnus-article-mouse-face))
(defun gnus-button-fetch-group (address)
"Fetch GROUP specified by ADDRESS."
- (if (not (string-match "^\\([^:/]+\\)\\(:\\([^/]+\\)\\)?/\\(.*\\)$" address))
- (error "Can't parse %s" address)
- (gnus-group-read-ephemeral-group
- (match-string 4 address)
- `(nntp ,(match-string 1 address) (nntp-address ,(match-string 1 address))
- (nntp-port-number ,(if (match-end 3)
- (match-string 3 address)
- "nntp"))))))
+ (if (not (string-match "[:/]" address))
+ ;; This is just a simple group url.
+ (gnus-group-read-ephemeral-group address gnus-select-method)
+ (if (not (string-match "^\\([^:/]+\\)\\(:\\([^/]+\\)/\\)?\\(.*\\)$"
+ address))
+ (error "Can't parse %s" address)
+ (gnus-group-read-ephemeral-group
+ (match-string 4 address)
+ `(nntp ,(match-string 1 address)
+ (nntp-address ,(match-string 1 address))
+ (nntp-port-number ,(if (match-end 3)
+ (match-string 3 address)
+ "nntp")))))))
(defun gnus-split-string (string pattern)
"Return a list of substrings of STRING which are separated by PATTERN."
(setq parts (cons (substring string start (match-beginning 0)) parts)
start (match-end 0)))
(nreverse (cons (substring string start) parts))))
-
+
(defun gnus-url-parse-query-string (query &optional downcase)
(let (retval pairs cur key val)
(setq pairs (gnus-split-string query "&"))
(setcdr cur (cons val (cdr cur)))
(setq retval (cons (list key val) retval)))))
retval))
-
+
(defun gnus-url-unhex (x)
(if (> x ?9)
(if (>= x ?a)
(+ 10 (- x ?a))
(+ 10 (- x ?A)))
(- x ?0)))
-
+
(defun gnus-url-unhex-string (str &optional allow-newlines)
"Remove %XXX embedded spaces, etc in a url.
If optional second argument ALLOW-NEWLINES is non-nil, then allow the
(ch1 (gnus-url-unhex (elt str (+ start 1))))
(code (+ (* 16 ch1)
(gnus-url-unhex (elt str (+ start 2))))))
- (setq tmp (concat
+ (setq tmp (concat
tmp (substring str 0 start)
(cond
(allow-newlines
str (substring str (match-end 0)))))
(setq tmp (concat tmp str))
tmp))
-
+
(defun gnus-url-mailto (url)
;; Send mail to someone
(when (string-match "mailto:/*\\(.*\\)" url)
(defun gnus-insert-prev-page-button ()
(let ((buffer-read-only nil))
- (gnus-eval-format
+ (gnus-eval-format
gnus-prev-page-line-format nil
`(gnus-prev t local-map ,gnus-prev-page-map
gnus-callback gnus-article-button-prev-page))))
(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-callback
gnus-article-button-next-page))))
(defun gnus-article-button-next-page (arg)
(let ((win (selected-window)))
(select-window (get-buffer-window gnus-article-buffer t))
(gnus-article-prev-page)
- (select-window win)))
+ (select-window win)))
(gnus-ems-redefine)
projects / gnus / blobdiff