]> code.delx.au - gnu-emacs/blobdiff - lisp/finder.el
(Abbrevs): A @node line without explicit Prev, Next, and Up links.
[gnu-emacs] / lisp / finder.el
index 3d8bb281fe75360e9af322a59e4dc0fb5989f898..1374e1f4e768d6844da8192955347998d4e1bfad 100644 (file)
@@ -1,6 +1,7 @@
 ;;; finder.el --- topic & keyword-based code finder
 
-;; Copyright (C) 1992, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 1997, 1998, 1999, 2001, 2002, 2003,
+;;   2004, 2005, 2006 Free Software Foundation, Inc.
 
 ;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
 ;; Created: 16 Jun 1992
@@ -21,8 +22,8 @@
 
 ;; 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., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
 
 ;;; Commentary:
 
 ;;; Code:
 
 (require 'lisp-mnt)
-(require 'finder-inf)
+(require 'find-func)                   ;for find-library(-suffixes)
+;; Use `load' rather than `require' so that it doesn't get loaded
+;; during byte-compilation (at which point it might be missing).
+(load "finder-inf" t t)
+
+(defvar finder-mode-hook nil
+  "*Hook run when function `finder-mode' is called.")
 
 ;; Local variable in finder buffer.
 (defvar finder-headmark)
 
+;; These are supposed to correspond to top-level customization groups,
+;; says rms.
 (defvar finder-known-keywords
   '(
     (abbrev    . "abbreviation handling, typing shortcuts, macros")
+    ;; Too specific:
     (bib       . "code related to the `bib' bibliography processor")
     (c         . "support for the C language and related languages")
     (calendar  . "calendar and time management support")
     (comm      . "communications, networking, remote access to files")
-    (data      . "support editing files of data")
+    (convenience . "convenience features for faster editing")
+    (data      . "support for editing files of data")
     (docs      . "support for Emacs documentation")
     (emulations        . "emulations of other editors")
     (extensions        . "Emacs Lisp language extensions")
     (faces     . "support for multiple fonts")
+    (files      . "support for editing and manipulating files")
     (frames     . "support for Emacs frames and window systems")
     (games     . "games, jokes and amusements")
     (hardware  . "support for interfacing with exotic hardware")
     (mail      . "modes for electronic-mail handling")
     (matching  . "various sorts of searching and matching")
     (mouse     . "mouse support")
+    (multimedia . "images and sound support")
     (news      . "support for netnews reading and posting")
     (oop        . "support for object-oriented programming")
     (outlines   . "support for hierarchical outlining")
     (processes . "process, subshell, compilation, and job control support")
     (terminals . "support for terminal types")
-    (tex       . "code related to the TeX formatter")
+    (tex       . "supporting code for the TeX formatter")
     (tools     . "programming tools")
-    (unix      . "front-ends/assistants for, or emulators of, UNIX features")
-    (vms       . "support code for vms")
+    (unix      . "front-ends/assistants for, or emulators of, UNIX-like features")
+;; Not a custom group and not currently useful.
+;;    (vms     . "support code for vms")
     (wp                . "word processing")
     ))
 
-(defvar finder-mode-map nil)
-(or finder-mode-map
-    (let ((map (make-sparse-keymap)))
-      (define-key map " "      'finder-select)
-      (define-key map "f"      'finder-select)
-      (define-key map [mouse-2]        'finder-mouse-select)
-      (define-key map "\C-m"   'finder-select)
-      (define-key map "?"      'finder-summary)
-      (define-key map "q"      'finder-exit)
-      (define-key map "d"      'finder-list-keywords)
-      (setq finder-mode-map map)))
+(defvar finder-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map " "        'finder-select)
+    (define-key map "f"        'finder-select)
+    (define-key map [follow-link] 'mouse-face)
+    (define-key map [mouse-2]  'finder-mouse-select)
+    (define-key map "\C-m"     'finder-select)
+    (define-key map "?"        'finder-summary)
+    (define-key map "n" 'next-line)
+    (define-key map "p" 'previous-line)
+    (define-key map "q"        'finder-exit)
+    (define-key map "d"        'finder-list-keywords)
+    map))
 
 
 ;;; Code for regenerating the keyword list.
 (defvar finder-package-info nil
   "Assoc list mapping file names to description & keyword lists.")
 
+(defvar generated-finder-keywords-file "finder-inf.el"
+  "File \\[finder-compile-keywords] puts finder keywords into.")
+
 (defun finder-compile-keywords (&rest dirs)
-  "Regenerate the keywords association list into the file `finder-inf.el'.
-Optional arguments are a list of Emacs Lisp directories to compile from; no
-arguments compiles from `load-path'."
+  "Regenerate the keywords association list into `generated-finder-keywords-file'.
+Optional arguments DIRS are a list of Emacs Lisp directories to compile from;
+no arguments compiles from `load-path'."
   (save-excursion
     (let ((processed nil))
-      (find-file "finder-inf.el")
+      (find-file generated-finder-keywords-file)
       (erase-buffer)
-      (insert ";;; finder-inf.el --- keyword-to-package mapping\n")
-      (insert ";; Keywords: help\n")
+      (insert ";;; " (file-name-nondirectory generated-finder-keywords-file)
+             " --- keyword-to-package mapping\n")
+      (insert ";; This file is part of GNU Emacs.\n")
       (insert ";;; Commentary:\n")
       (insert ";; Don't edit this file.  It's generated by finder.el\n\n")
       (insert ";;; Code:\n")
       (insert "\n(setq finder-package-info '(\n")
       (mapcar
        (lambda (d)
-        (mapcar
-         (lambda (f) 
-           (if (and (or (string-match "^[^=].*\\.el$" f)
-                        ;; Allow compressed files also.  Fixme:
-                        ;; generalize this, especially for
-                        ;; MS-DOG-type filenames.
-                        (and (string-match "^[^=].*\\.el\\.\\(gz\\|Z\\)$" f)
-                             (require 'jka-compr)))
-                    (not (member f processed)))
-               (let (summary keystart keywords)
-                 (setq processed (cons f processed))
-                 (save-excursion
-                   (set-buffer (get-buffer-create "*finder-scratch*"))
-                   (buffer-disable-undo (current-buffer))
-                   (erase-buffer)
-                   (insert-file-contents
-                    (concat (file-name-as-directory (or d ".")) f))
-                   (setq summary (lm-synopsis))
-                   (setq keywords (lm-keywords)))
-                 (insert
-                  (format "    (\"%s\"\n        "
-                          (if (string-match "\\.\\(gz\\|Z\\)$" f)
-                              (file-name-sans-extension f) 
-                            f)))
-                 (prin1 summary (current-buffer))
-                 (insert
-                  "\n        ")
-                 (setq keystart (point))
-                 (insert
-                  (if keywords (format "(%s)" keywords) "nil")
-                  ")\n")
-                 (subst-char-in-region keystart (point) ?, ? )
-                 )))
-         (directory-files (or d "."))))
+        (when (file-exists-p (directory-file-name d))
+          (message "Directory %s" d)
+          (mapcar
+           (lambda (f)
+             (if (and (or (string-match "^[^=].*\\.el$" f)
+                          ;; Allow compressed files also.  Fixme:
+                          ;; generalize this, especially for
+                          ;; MS-DOG-type filenames.
+                          (and (string-match "^[^=].*\\.el\\.\\(gz\\|Z\\)$" f)
+                               (require 'jka-compr)))
+                      ;; Ignore lock files.
+                      (not (string-match "^.#" f))
+                      (not (member f processed)))
+                 (let (summary keystart keywords)
+                   (setq processed (cons f processed))
+                   (save-excursion
+                     (set-buffer (get-buffer-create "*finder-scratch*"))
+                     (buffer-disable-undo (current-buffer))
+                     (erase-buffer)
+                     (insert-file-contents
+                      (concat (file-name-as-directory (or d ".")) f))
+                     (setq summary (lm-synopsis))
+                     (setq keywords (lm-keywords)))
+                   (insert
+                    (format "    (\"%s\"\n        "
+                            (if (string-match "\\.\\(gz\\|Z\\)$" f)
+                                (file-name-sans-extension f)
+                              f)))
+                   (prin1 summary (current-buffer))
+                   (insert
+                    "\n        ")
+                   (setq keystart (point))
+                   (insert
+                    (if keywords (format "(%s)" keywords) "nil")
+                    ")\n")
+                   (subst-char-in-region keystart (point) ?, ? )
+                   )))
+           (directory-files (or d ".")))))
        (or dirs load-path))
-      (insert "))\n\n(provide 'finder-inf)\n\n;;; finder-inf.el ends here\n")
+      (insert "))\n
+\(provide '" (file-name-sans-extension
+             (file-name-nondirectory generated-finder-keywords-file)) ")
+
+;;; Local Variables:
+;;; version-control: never
+;;; no-byte-compile: t
+;;; no-update-autoloads: t
+;;; End:
+;;; " (file-name-nondirectory generated-finder-keywords-file) " ends here\n")
       (kill-buffer "*finder-scratch*")
-      (eval-current-buffer) ;; So we get the new keyword list immediately
+      (eval-buffer) ;; So we get the new keyword list immediately
       (basic-save-buffer))))
 
 (defun finder-compile-keywords-make-dist ()
@@ -164,20 +197,32 @@ arguments compiles from `load-path'."
 ;;; Now the retrieval code
 
 (defun finder-insert-at-column (column &rest strings)
-  "Insert list of STRINGS, at column COLUMN."
-  (if (> (current-column) column) (insert "\n"))
-  (move-to-column column)
-  (let ((col (current-column)))
-    (if (< col column)
-       (indent-to column)
-      (if (and (/= col column)
-              (= (preceding-char) ?\t))
-         (let (indent-tabs-mode)
-           (delete-char -1)
-            (indent-to col)
-            (move-to-column column)))))
+  "Insert, at column COLUMN, other args STRINGS."
+  (if (>= (current-column) column) (insert "\n"))
+  (move-to-column column t)
   (apply 'insert strings))
 
+(defvar finder-help-echo nil)
+
+(defun finder-mouse-face-on-line ()
+  "Put `mouse-face' and `help-echo' properties on the previous line."
+  (save-excursion
+    (previous-line 1)
+    (unless finder-help-echo
+      (setq finder-help-echo
+           (let* ((keys1 (where-is-internal 'finder-select
+                                            finder-mode-map))
+                  (keys (nconc (where-is-internal
+                                'finder-mouse-select finder-mode-map)
+                               keys1)))
+             (concat (mapconcat 'key-description keys ", ")
+                     ": select item"))))
+    (add-text-properties
+     (line-beginning-position) (line-end-position)
+     '(mouse-face highlight
+                 help-echo finder-help-echo))))
+
+;;;###autoload
 (defun finder-list-keywords ()
   "Display descriptions of the keywords in the Finder buffer."
   (interactive)
@@ -187,12 +232,12 @@ arguments compiles from `load-path'."
     (finder-mode)
     (setq buffer-read-only nil)
     (erase-buffer)
-    (mapcar
+    (mapc
      (lambda (assoc)
        (let ((keyword (car assoc)))
         (insert (symbol-name keyword))
         (finder-insert-at-column 14 (concat (cdr assoc) "\n"))
-        (cons (symbol-name keyword) keyword)))
+        (finder-mouse-face-on-line)))
      finder-known-keywords)
     (goto-char (point-min))
     (setq finder-headmark (point))
@@ -210,12 +255,13 @@ arguments compiles from `load-path'."
     (insert
      "The following packages match the keyword `" key "':\n\n")
     (setq finder-headmark (point))
-    (mapcar
+    (mapc
      (lambda (x)
        (if (memq id (car (cdr (cdr x))))
           (progn
             (insert (car x))
-            (finder-insert-at-column 16 (concat (car (cdr x)) "\n")))))
+            (finder-insert-at-column 16 (concat (nth 1 x) "\n"))
+            (finder-mouse-face-on-line))))
      finder-package-info)
     (goto-char (point-min))
     (forward-line)
@@ -224,22 +270,23 @@ arguments compiles from `load-path'."
     (shrink-window-if-larger-than-buffer)
     (finder-summary)))
 
-;; Search for a file named FILE on `load-path', also trying compressed
-;; versions if jka-compr is in use.
-(defun finder-find-library (library)
-  (or (locate-library library t)
-      (if (rassq 'jka-compr-handler file-name-handler-alist)
-        (or (locate-library (concat library ".gz") t)
-            (locate-library (concat library ".Z") t)
-            ;; last resort for MS-DOG et al
-            (locate-library (concat library "z"))))))
-
+;;;###autoload
 (defun finder-commentary (file)
-  (interactive)
-  (let* ((str (lm-commentary (finder-find-library file))))
+  "Display FILE's commentary section.
+FILE should be in a form suitable for passing to `locate-library'."
+  (interactive
+   (list
+    (completing-read "Library name: "
+                    'locate-file-completion
+                    (cons (or find-function-source-path load-path)
+                          (find-library-suffixes)))))
+  (let* ((str (lm-commentary (find-library-name file))))
     (if (null str)
        (error "Can't find any Commentary section"))
-    (pop-to-buffer "*Finder*")
+    ;; This used to use *Finder* but that would clobber the
+    ;; directory of categories.
+    (delete-other-windows)
+    (pop-to-buffer "*Finder-package*")
     (setq buffer-read-only nil)
     (erase-buffer)
     (insert str)
@@ -254,16 +301,20 @@ arguments compiles from `load-path'."
     (setq buffer-read-only t)
     (set-buffer-modified-p nil)
     (shrink-window-if-larger-than-buffer)
+    (finder-mode)
     (finder-summary)))
 
 (defun finder-current-item ()
-  (if (and finder-headmark (< (point) finder-headmark))
-      (error "No keyword or filename on this line")
-    (save-excursion
-      (beginning-of-line)
-      (current-word))))
+  (let ((key (save-excursion
+              (beginning-of-line)
+              (current-word))))
+    (if (or (and finder-headmark (< (point) finder-headmark))
+           (= (length key) 0))
+       (error "No keyword or filename on this line")
+      key)))
 
 (defun finder-select ()
+  "Select item on current line in a finder buffer."
   (interactive)
   (let ((key (finder-current-item)))
       (if (string-match "\\.el$" key)
@@ -271,13 +322,14 @@ arguments compiles from `load-path'."
        (finder-list-matches key))))
 
 (defun finder-mouse-select (event)
+  "Select item in a finder buffer with the mouse."
   (interactive "e")
   (save-excursion
-       (set-buffer (window-buffer (posn-window (event-start event))))
-       (goto-char (posn-point (event-start event)))
-       (let ((key (finder-current-item)))
-      (finder-select))))
+    (set-buffer (window-buffer (posn-window (event-start event))))
+    (goto-char (posn-point (event-start event)))
+    (finder-select)))
 
+;;;###autoload
 (defun finder-by-keyword ()
   "Find packages matching a given keyword."
   (interactive)
@@ -287,22 +339,24 @@ arguments compiles from `load-path'."
   "Major mode for browsing package documentation.
 \\<finder-mode-map>
 \\[finder-select]      more help for the item on the current line
-\\[finder-exit]        exit Finder mode and kill the Finder buffer.
-"
+\\[finder-exit]        exit Finder mode and kill the Finder buffer."
   (interactive)
+  (kill-all-local-variables)
   (use-local-map finder-mode-map)
   (set-syntax-table emacs-lisp-mode-syntax-table)
   (setq mode-name "Finder")
   (setq major-mode 'finder-mode)
-  (make-local-variable 'finder-headmark)
-  (setq finder-headmark nil))
+  (set (make-local-variable 'finder-headmark) nil)
+  (run-mode-hooks 'finder-mode-hook))
 
 (defun finder-summary ()
   "Summarize basic Finder commands."
   (interactive)
   (message "%s"
    (substitute-command-keys
-    "\\<finder-mode-map>\\[finder-select] = select, \\[finder-mouse-select] = select, \\[finder-list-keywords] = to finder directory, \\[finder-exit] = quit, \\[finder-summary] = help")))
+    "\\<finder-mode-map>\\[finder-select] = select, \
+\\[finder-mouse-select] = select, \\[finder-list-keywords] = to \
+finder directory, \\[finder-exit] = quit, \\[finder-summary] = help")))
 
 (defun finder-exit ()
   "Exit Finder mode and kill the buffer."
@@ -315,6 +369,8 @@ arguments compiles from `load-path'."
   (and (get-buffer "*Finder Category*")
        (kill-buffer "*Finder Category*")))
 
+\f
 (provide 'finder)
 
+;;; arch-tag: ec85ff49-8cb8-41f5-a63f-9131d53ce2c5
 ;;; finder.el ends here