1 ;;; list-mode.el --- Major mode for buffers containing lists of items
3 ;; Copyright (C) 1992-4, 1997 Free Software Foundation, Inc.
4 ;; Copyright (C) 1996 Ben Wing.
6 ;; Maintainer: XEmacs Development Team
7 ;; Keywords: extensions, dumped
9 ;; This file is part of XEmacs.
11 ;; XEmacs is free software; you can redistribute it and/or modify it
12 ;; under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
16 ;; XEmacs is distributed in the hope that it will be useful, but
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 ;; General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with XEmacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
26 ;;; Synched up with: Not synched
30 ;; This file is dumped with XEmacs.
32 ;; Cleanup, merging with FSF by Ben Wing, January 1996
36 (defvar list-mode-extent nil)
37 (make-variable-buffer-local 'list-mode-extent)
39 (defvar list-mode-map nil
40 "Local map for buffers containing lists of items.")
42 (let ((map (setq list-mode-map (make-sparse-keymap 'list-mode-map))))
44 (define-key map 'button2up 'list-mode-item-mouse-selected)
45 (define-key map 'button2 'undefined)
46 (define-key map "\C-m" 'list-mode-item-keyboard-selected)
48 ;; The following calls to `substitute-key-definition' losed because
49 ;; they were based on an incorrect assumption that `forward-char' and
50 ;; `backward-char' are bound to keys in the global map. This might not
51 ;; be the case if a user binds motion keys to different functions,
52 ;; and was not actually the case since 20.5 beta 28 or around.
54 ;; (substitute-key-definition 'forward-char 'next-list-mode-item map
56 ;; (substitute-key-definition 'backward-char 'previous-list-mode-item map
59 ;; We bind standard keys to motion commands instead.
61 (dolist (key '(kp-right right (control ?f)))
62 (define-key map key 'next-list-mode-item))
63 (dolist (key '(kp-left left (control ?b)))
64 (define-key map key 'previous-list-mode-item))))
67 "Major mode for buffer containing lists of items."
69 (kill-all-local-variables)
70 (use-local-map list-mode-map)
71 (setq mode-name "List")
72 (setq major-mode 'list-mode)
73 (make-local-hook 'post-command-hook)
74 (add-hook 'post-command-hook 'set-list-mode-extent nil t)
75 (make-local-hook 'pre-command-hook)
76 (add-hook 'pre-command-hook 'list-mode-extent-pre-hook nil t)
77 (make-local-variable 'next-line-add-newlines)
78 (setq next-line-add-newlines nil)
79 (setq list-mode-extent nil)
80 (set-specifier text-cursor-visible-p nil (current-buffer))
81 (setq buffer-read-only t)
82 (goto-char (point-min))
83 (run-hooks 'list-mode-hook))
85 ;; List mode is suitable only for specially formatted data.
86 (put 'list-mode 'mode-class 'special)
88 (defvar list-mode-extent-old-point nil
89 "The value of point when pre-command-hook is called.
90 Used to determine the direction of motion.")
91 (make-variable-buffer-local 'list-mode-extent-old-point)
93 (defun list-mode-extent-pre-hook ()
94 (setq list-mode-extent-old-point (point))
95 ;(setq atomic-extent-goto-char-p nil)
98 (defun set-list-mode-extent ()
99 "Move to the closest list item and set up the extent for it.
100 This is called from `post-command-hook'."
101 (cond ((get-char-property (point) 'list-mode-item))
102 ((and (> (point) (point-min))
103 (get-char-property (1- (point)) 'list-mode-item))
104 (goto-char (1- (point))))
108 ;this fucks things up more than it helps.
109 ;atomic-extent-goto-char-p as currently defined is all broken,
110 ;since it will be triggered if the command *ever* runs goto-char!
111 ;(if atomic-extent-goto-char-p
113 (if (and list-mode-extent-old-point
114 (> pos list-mode-extent-old-point))
117 (next-list-mode-item dirflag)
118 (or (get-char-property (point) 'list-mode-item)
119 (next-list-mode-item (- dirflag))))))
120 (or (and list-mode-extent
121 (eq (current-buffer) (extent-object list-mode-extent)))
123 (setq list-mode-extent (make-extent nil nil (current-buffer)))
124 (set-extent-face list-mode-extent 'list-mode-item-selected)))
125 (let ((ex (extent-at (point) nil 'list-mode-item nil 'at)))
128 (set-extent-endpoints list-mode-extent
129 (extent-start-position ex)
130 (extent-end-position ex))
131 (auto-show-make-region-visible (extent-start-position ex)
132 (extent-end-position ex)))
133 (detach-extent list-mode-extent))))
135 (defun previous-list-mode-item (n)
136 "Move to the previous item in list-mode."
138 (next-list-mode-item (- n)))
140 (defun next-list-mode-item (n)
141 "Move to the next item in list-mode.
142 With prefix argument N, move N items (negative N means move backward)."
144 (while (and (> n 0) (not (eobp)))
145 (let ((extent (extent-at (point) (current-buffer) 'list-mode-item))
147 ;; If in a completion, move to the end of it.
148 (if extent (goto-char (extent-end-position extent)))
149 ;; Move to start of next one.
150 (or (extent-at (point) (current-buffer) 'list-mode-item)
151 (goto-char (next-single-property-change (point) 'list-mode-item
154 (while (and (< n 0) (not (bobp)))
155 (let ((extent (extent-at (point) (current-buffer) 'list-mode-item))
157 ;; If in a completion, move to the start of it.
158 (if extent (goto-char (extent-start-position extent)))
159 ;; Move to the start of that one.
160 (if (setq extent (extent-at (point) (current-buffer) 'list-mode-item
162 (goto-char (extent-start-position extent))
163 (goto-char (previous-single-property-change
164 (point) 'list-mode-item nil end))
165 (if (setq extent (extent-at (point) (current-buffer) 'list-mode-item
167 (goto-char (extent-start-position extent)))))
170 (defun list-mode-item-selected-1 (extent event)
171 (let ((func (extent-property extent 'list-mode-item-activate-callback))
172 (user-data (extent-property extent 'list-mode-item-user-data)))
174 (funcall func event extent user-data))))
176 ;; we could make these two be just one function, but we want to be
177 ;; able to refer to them in DOC strings.
179 (defun list-mode-item-keyboard-selected ()
181 (list-mode-item-selected-1 (extent-at (point) (current-buffer)
182 'list-mode-item nil 'at)
185 (defun list-mode-item-mouse-selected (event)
187 ;; Sometimes event-closest-point returns nil.
188 ;; So beep instead of bombing.
189 (let ((point (event-closest-point event)))
191 (list-mode-item-selected-1 (extent-at point
193 'list-mode-item nil 'at)
197 (defun add-list-mode-item (start end &optional buffer activate-callback
199 "Add a new list item in list-mode, from START to END in BUFFER.
200 BUFFER defaults to the current buffer.
201 This works by creating an extent for the span of text in question.
202 If ACTIVATE-CALLBACK is non-nil, it should be a function of three
203 arguments (EVENT EXTENT USER-DATA) that will be called when button2
204 is pressed on the extent. USER-DATA comes from the optional
206 (let ((extent (make-extent start end buffer)))
207 (set-extent-property extent 'list-mode-item t)
208 (set-extent-property extent 'start-open t)
209 (if activate-callback
211 (set-extent-property extent 'mouse-face 'highlight)
212 (set-extent-property extent 'list-mode-item-activate-callback
214 (set-extent-property extent 'list-mode-item-user-data user-data)))
218 ;; Define the major mode for lists of completions.
221 (defvar completion-highlight-first-word-only nil
222 "*Completion will only highlight the first blank delimited word if t.
223 If the variable in not t or nil, the string is taken as a regexp to match for end
226 (defvar completion-setup-hook nil
227 "Normal hook run at the end of setting up the text of a completion buffer.")
229 ; Unnecessary FSFmacs crock. We frob the extents directly in
230 ; display-completion-list, so no "heuristics" like this are necessary.
231 ;(defvar completion-fixup-function nil
232 ; "A function to customize how completions are identified in completion lists.
233 ;`completion-setup-function' calls this function with no arguments
234 ;each time it has found what it thinks is one completion.
235 ;Point is at the end of the completion in the completion list buffer.
236 ;If this function moves point, it can alter the end of that completion.")
238 (defvar completion-default-help-string
240 (if (device-on-window-system-p)
241 (substitute-command-keys
242 "Click \\<list-mode-map>\\[list-mode-item-mouse-selected] on a completion to select it.\n") "")
243 (substitute-command-keys
244 "Type \\<minibuffer-local-completion-map>\\[advertised-switch-to-completions] or \\[switch-to-completions] to move to this buffer, for keyboard selection.\n\n"))
245 "Form the evaluate to get a help string for completion lists.
246 This string is inserted at the beginning of the buffer.
247 See `display-completion-list'.")
249 (defun display-completion-list (completions &rest cl-keys)
250 "Display the list of completions, COMPLETIONS, using `standard-output'.
251 Each element may be just a symbol or string or may be a list of two
252 strings to be printed as if concatenated.
253 Frob a mousable extent onto each completion. This extent has properties
254 'mouse-face (so it highlights when the mouse passes over it) and
255 'list-mode-item (so it can be located).
258 :activate-callback (default is `default-choose-completion')
259 See `add-list-mode-item'.
261 Value passed to activation callback.
263 If non-nil, width to use in displaying the list, instead of the
264 actual window's width.
265 :help-string (default is the value of `completion-default-help-string')
266 Form to evaluate to get a string to insert at the beginning of
267 the completion list buffer. This is evaluated when that buffer
268 is the current buffer and after it has been put into
269 completion-list-mode.
270 :reference-buffer (default is the current buffer)
271 This specifies the value of `completion-reference-buffer' in
272 the completion buffer. This specifies the buffer (normally a
273 minibuffer) that `default-choose-completion' will insert the
276 At the end, run the normal hook `completion-setup-hook'.
277 It can find the completion buffer in `standard-output'.
278 If `completion-highlight-first-word-only' is non-nil, then only the start
279 of the string is highlighted."
280 ;; #### I18N3 should set standard-output to be (temporarily)
281 ;; output-translating.
283 ((:activate-callback 'default-choose-completion)
286 (:help-string completion-default-help-string)
289 (let ((old-buffer (current-buffer))
290 (bufferp (bufferp standard-output)))
292 (set-buffer standard-output))
293 (if (null completions)
295 "There are no possible completions of what you have typed."))
299 ;; This needs fixing for the case of windows
300 ;; that aren't the same width's the frame.
301 ;; Sadly, the window it will appear in is not known
302 ;; until after the text has been made.
304 ;; We have to use last-nonminibuf-frame here
305 ;; and not selected-frame because if a
306 ;; minibuffer-only frame is being used it will
307 ;; be the selected-frame at the point this is
308 ;; run. We keep the selected-frame call around
310 (frame-width (or (last-nonminibuf-frame)
315 ;; Find longest completion
316 (let ((tail completions))
318 (let* ((elt (car tail))
319 (len (cond ((stringp elt)
323 (stringp (car (cdr elt))))
324 (+ (length (car elt))
325 (length (car (cdr elt)))))
327 (signal 'wrong-type-argument
328 (list 'stringp elt))))))
329 (if (> len max-width)
330 (setq max-width len))
331 (setq count (1+ count)
334 (setq max-width (+ 2 max-width)) ; at least two chars between cols
335 (let ((rows (let ((cols (min (/ win-width max-width) count)))
339 ;; re-space the columns
340 (setq max-width (/ win-width cols))
341 (if (/= (% count cols) 0) ; want ceiling...
344 (princ (gettext "Possible completions are:"))
345 (let ((tail completions)
349 completion-highlight-first-word-only)
351 completion-highlight-first-word-only)))
358 (let ((elt (car tail2)))
362 (while (progn (write-char ?\ )
363 (setq column (1+ column))
364 (< column indent)))))
365 (setq indent (+ indent max-width))
366 (let ((start (point))
368 ;; Frob some mousable extents in there too!
372 (princ (car (cdr elt)))
377 (length (car (cdr elt)))))))
381 (setq column (+ column (length
388 (and completion-highlight-first-word-only
390 (re-search-forward regexp-string end t)
393 nil cl-activate-callback cl-user-data)
395 (setq tail2 (nthcdr rows tail2)))
396 (setq tail (cdr tail)
399 (set-buffer old-buffer)))
401 (let ((mainbuf (or cl-reference-buffer (current-buffer))))
402 (set-buffer standard-output)
403 (completion-list-mode)
404 (make-local-variable 'completion-reference-buffer)
405 (setq completion-reference-buffer mainbuf)
406 ;;; The value 0 is right in most cases, but not for file name completion.
407 ;;; so this has to be turned off.
408 ;;; (setq completion-base-size 0)
409 (goto-char (point-min))
410 (let ((buffer-read-only nil))
411 (insert (eval cl-help-string)))
412 ;; unnecessary FSFmacs crock
414 ;;(while (re-search-forward "[^ \t\n]+\\( [^ \t\n]+\\)*" nil t)
415 ;; (let ((beg (match-beginning 0))
417 ;; (if completion-fixup-function
418 ;; (funcall completion-fixup-function))
419 ;; (put-text-property beg (point) 'mouse-face 'highlight)
420 ;; (put-text-property beg (point) 'list-mode-item t)
421 ;; (goto-char end)))))
423 (run-hooks 'completion-setup-hook)))
425 (defvar completion-display-completion-list-function 'display-completion-list
426 "Function to set up the list of completions in the completion buffer.
427 The function is called with one argument, the sorted list of completions.
428 Particular minibuffer interface functions (e.g. `read-file-name') may
429 want to change this. To do that, set a local value for this variable
430 in the minibuffer; that ensures that other minibuffer invocations will
433 (defun minibuffer-completion-help ()
434 "Display a list of possible completions of the current minibuffer contents.
435 The list of completions is determined by calling `all-completions',
436 passing it the current minibuffer contents, the value of
437 `minibuffer-completion-table', and the value of
438 `minibuffer-completion-predicate'. The list is displayed by calling
439 the value of `completion-display-completion-list-function' on the sorted
440 list of completions, with the standard output set to the completion
443 (message "Making completion list...")
444 (let ((completions (all-completions (buffer-string)
445 minibuffer-completion-table
446 minibuffer-completion-predicate)))
448 (if (null completions)
450 (ding nil 'no-completion)
451 (temp-minibuffer-message " [No completions]"))
452 (with-output-to-temp-buffer "*Completions*"
453 (funcall completion-display-completion-list-function
454 (sort completions #'string-lessp))))))
456 (define-derived-mode completion-list-mode list-mode
458 "Major mode for buffers showing lists of possible completions.
459 Type \\<completion-list-mode-map>\\[choose-completion] in the completion list\
460 to select the completion near point.
461 Use \\<completion-list-mode-map>\\[mouse-choose-completion] to select one\
463 (make-local-variable 'completion-base-size)
464 (setq completion-base-size nil))
466 (let ((map completion-list-mode-map))
467 (define-key map "\e\e\e" 'delete-completion-window)
468 (define-key map "\C-g" 'minibuffer-keyboard-quit)
469 (define-key map "q" 'abort-recursive-edit)
470 (define-key map " " (lambda () (interactive)
471 (select-window (minibuffer-window))))
472 (define-key map "\t" (lambda () (interactive)
473 (select-window (minibuffer-window)))))
475 (defvar completion-reference-buffer nil
476 "Record the buffer that was current when the completion list was requested.
477 This is a local variable in the completion list buffer.
478 Initial value is nil to avoid some compiler warnings.")
480 (defvar completion-base-size nil
481 "Number of chars at beginning of minibuffer not involved in completion.
482 This is a local variable in the completion list buffer
483 but it talks about the buffer in `completion-reference-buffer'.
484 If this is nil, it means to compare text to determine which part
485 of the tail end of the buffer's text is involved in completion.")
487 (defun delete-completion-window ()
488 "Delete the completion list window.
489 Go to the window from which completion was requested."
491 (let ((buf completion-reference-buffer))
492 (delete-window (selected-window))
493 (if (get-buffer-window buf)
494 (select-window (get-buffer-window buf)))))
496 (defun completion-do-in-minibuffer ()
499 (set-buffer (window-buffer (minibuffer-window)))
500 (call-interactively (key-binding (this-command-keys)))))
502 (defun default-choose-completion (event extent buffer)
503 "Click on an alternative in the `*Completions*' buffer to choose it."
504 (and (button-event-p event)
505 ;; Give temporary modes such as isearch a chance to turn off.
506 (run-hooks 'mouse-leave-buffer-hook))
507 (or buffer (setq buffer (symbol-value-in-buffer
508 'completion-reference-buffer
509 (or (and (button-event-p event)
510 (event-buffer event))
512 (save-selected-window
513 (and (button-event-p event)
514 (select-window (event-window event)))
515 (if (and (one-window-p t 'selected-frame)
516 (window-dedicated-p (selected-window)))
517 ;; This is a special buffer's frame
518 (iconify-frame (selected-frame))
519 (or (window-dedicated-p (selected-window))
521 (choose-completion-string (extent-string extent)
523 completion-base-size))
525 ;; Delete the longest partial match for STRING
526 ;; that can be found before POINT.
527 (defun choose-completion-delete-max-match (string)
528 (let ((len (min (length string)
529 (- (point) (point-min)))))
530 (goto-char (- (point) (length string)))
531 (if completion-ignore-case
532 (setq string (downcase string)))
533 (while (and (> len 0)
534 (let ((tail (buffer-substring (point)
536 (if completion-ignore-case
537 (setq tail (downcase tail)))
538 (not (string= tail (substring string 0 len)))))
543 ;; Switch to BUFFER and insert the completion choice CHOICE.
544 ;; BASE-SIZE, if non-nil, says how many characters of BUFFER's text
545 ;; to keep. If it is nil, use choose-completion-delete-max-match instead.
546 (defun choose-completion-string (choice &optional buffer base-size)
547 (let ((buffer (or buffer completion-reference-buffer)))
548 ;; If BUFFER is a minibuffer, barf unless it's the currently
549 ;; active minibuffer.
550 (if (and (string-match "\\` \\*Minibuf-[0-9]+\\*\\'" (buffer-name buffer))
551 (or (not (active-minibuffer-window))
553 (window-buffer (active-minibuffer-window))))))
554 (error "Minibuffer is not active for completion")
555 ;; Insert the completion into the buffer where completion was requested.
558 (delete-region (+ base-size (point-min)) (point))
559 (choose-completion-delete-max-match choice))
561 (remove-text-properties (- (point) (length choice)) (point)
563 ;; Update point in the window that BUFFER is showing in.
564 (let ((window (get-buffer-window buffer t)))
565 (set-window-point window (point)))
566 ;; If completing for the minibuffer, exit it with this choice.
567 (and (equal buffer (window-buffer (minibuffer-window)))
568 minibuffer-completion-table
569 (exit-minibuffer)))))
571 (define-key minibuffer-local-completion-map [prior]
572 'switch-to-completions)
573 (define-key minibuffer-local-must-match-map [prior]
574 'switch-to-completions)
575 (define-key minibuffer-local-completion-map "\M-v"
576 'advertised-switch-to-completions)
577 (define-key minibuffer-local-must-match-map "\M-v"
578 'advertised-switch-to-completions)
580 (defalias 'advertised-switch-to-completions 'switch-to-completions)
581 (defun switch-to-completions ()
582 "Select the completion list window."
584 ;; Make sure we have a completions window.
585 (or (get-buffer-window "*Completions*")
586 (minibuffer-completion-help))
587 (if (not (get-buffer-window "*Completions*"))
589 (select-window (get-buffer-window "*Completions*"))
590 (goto-char (next-single-property-change (point-min) 'list-mode-item nil
593 ;;; list-mode.el ends here