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)
287 (:completion-string "Possible completions are:")
290 (let ((old-buffer (current-buffer))
291 (bufferp (bufferp standard-output)))
293 (set-buffer standard-output))
294 (if (null completions)
296 "There are no possible completions of what you have typed."))
300 ;; This needs fixing for the case of windows
301 ;; that aren't the same width's the frame.
302 ;; Sadly, the window it will appear in is not known
303 ;; until after the text has been made.
305 ;; We have to use last-nonminibuf-frame here
306 ;; and not selected-frame because if a
307 ;; minibuffer-only frame is being used it will
308 ;; be the selected-frame at the point this is
309 ;; run. We keep the selected-frame call around
311 (frame-width (or (last-nonminibuf-frame)
316 ;; Find longest completion
317 (let ((tail completions))
319 (let* ((elt (car tail))
320 (len (cond ((stringp elt)
324 (stringp (car (cdr elt))))
325 (+ (length (car elt))
326 (length (car (cdr elt)))))
328 (signal 'wrong-type-argument
329 (list 'stringp elt))))))
330 (if (> len max-width)
331 (setq max-width len))
332 (setq count (1+ count)
335 (setq max-width (+ 2 max-width)) ; at least two chars between cols
336 (let ((rows (let ((cols (min (/ win-width max-width) count)))
340 ;; re-space the columns
341 (setq max-width (/ win-width cols))
342 (if (/= (% count cols) 0) ; want ceiling...
345 (if (stringp cl-completion-string)
346 (princ (gettext cl-completion-string)))
347 (let ((tail completions)
351 completion-highlight-first-word-only)
353 completion-highlight-first-word-only)))
360 (let ((elt (car tail2)))
364 (while (progn (write-char ?\ )
365 (setq column (1+ column))
366 (< column indent)))))
367 (setq indent (+ indent max-width))
368 (let ((start (point))
370 ;; Frob some mousable extents in there too!
374 (princ (car (cdr elt)))
379 (length (car (cdr elt)))))))
383 (setq column (+ column (length
390 (and completion-highlight-first-word-only
392 (re-search-forward regexp-string end t)
395 nil cl-activate-callback cl-user-data)
397 (setq tail2 (nthcdr rows tail2)))
398 (setq tail (cdr tail)
401 (set-buffer old-buffer)))
403 (let ((mainbuf (or cl-reference-buffer (current-buffer))))
404 (set-buffer standard-output)
405 (completion-list-mode)
406 (make-local-variable 'completion-reference-buffer)
407 (setq completion-reference-buffer mainbuf)
408 ;;; The value 0 is right in most cases, but not for file name completion.
409 ;;; so this has to be turned off.
410 ;;; (setq completion-base-size 0)
411 (goto-char (point-min))
412 (let ((buffer-read-only nil))
413 (insert (eval cl-help-string)))
414 ;; unnecessary FSFmacs crock
416 ;;(while (re-search-forward "[^ \t\n]+\\( [^ \t\n]+\\)*" nil t)
417 ;; (let ((beg (match-beginning 0))
419 ;; (if completion-fixup-function
420 ;; (funcall completion-fixup-function))
421 ;; (put-text-property beg (point) 'mouse-face 'highlight)
422 ;; (put-text-property beg (point) 'list-mode-item t)
423 ;; (goto-char end)))))
425 (run-hooks 'completion-setup-hook)))
427 (defvar completion-display-completion-list-function 'display-completion-list
428 "Function to set up the list of completions in the completion buffer.
429 The function is called with one argument, the sorted list of completions.
430 Particular minibuffer interface functions (e.g. `read-file-name') may
431 want to change this. To do that, set a local value for this variable
432 in the minibuffer; that ensures that other minibuffer invocations will
435 (defun minibuffer-completion-help ()
436 "Display a list of possible completions of the current minibuffer contents.
437 The list of completions is determined by calling `all-completions',
438 passing it the current minibuffer contents, the value of
439 `minibuffer-completion-table', and the value of
440 `minibuffer-completion-predicate'. The list is displayed by calling
441 the value of `completion-display-completion-list-function' on the sorted
442 list of completions, with the standard output set to the completion
445 (message "Making completion list...")
446 (let ((completions (all-completions (buffer-string)
447 minibuffer-completion-table
448 minibuffer-completion-predicate)))
450 (if (null completions)
452 (ding nil 'no-completion)
453 (temp-minibuffer-message " [No completions]"))
454 (with-output-to-temp-buffer "*Completions*"
455 (funcall completion-display-completion-list-function
456 (sort completions #'string-lessp))))))
458 (define-derived-mode completion-list-mode list-mode
460 "Major mode for buffers showing lists of possible completions.
461 Type \\<completion-list-mode-map>\\[choose-completion] in the completion list\
462 to select the completion near point.
463 Use \\<completion-list-mode-map>\\[mouse-choose-completion] to select one\
465 (make-local-variable 'completion-base-size)
466 (setq completion-base-size nil))
468 (let ((map completion-list-mode-map))
469 (define-key map "\e\e\e" 'delete-completion-window)
470 (define-key map "\C-g" 'minibuffer-keyboard-quit)
471 (define-key map "q" 'abort-recursive-edit)
472 (define-key map " " (lambda () (interactive)
473 (select-window (minibuffer-window))))
474 (define-key map "\t" (lambda () (interactive)
475 (select-window (minibuffer-window)))))
477 (defvar completion-reference-buffer nil
478 "Record the buffer that was current when the completion list was requested.
479 This is a local variable in the completion list buffer.
480 Initial value is nil to avoid some compiler warnings.")
482 (defvar completion-base-size nil
483 "Number of chars at beginning of minibuffer not involved in completion.
484 This is a local variable in the completion list buffer
485 but it talks about the buffer in `completion-reference-buffer'.
486 If this is nil, it means to compare text to determine which part
487 of the tail end of the buffer's text is involved in completion.")
489 (defun delete-completion-window ()
490 "Delete the completion list window.
491 Go to the window from which completion was requested."
493 (let ((buf completion-reference-buffer))
494 (delete-window (selected-window))
495 (if (get-buffer-window buf)
496 (select-window (get-buffer-window buf)))))
498 (defun completion-do-in-minibuffer ()
501 (set-buffer (window-buffer (minibuffer-window)))
502 (call-interactively (key-binding (this-command-keys)))))
504 (defun default-choose-completion (event extent buffer)
505 "Click on an alternative in the `*Completions*' buffer to choose it."
506 (and (button-event-p event)
507 ;; Give temporary modes such as isearch a chance to turn off.
508 (run-hooks 'mouse-leave-buffer-hook))
509 (or buffer (setq buffer (symbol-value-in-buffer
510 'completion-reference-buffer
511 (or (and (button-event-p event)
512 (event-buffer event))
514 (save-selected-window
515 (and (button-event-p event)
516 (select-window (event-window event)))
517 (if (and (one-window-p t 'selected-frame)
518 (window-dedicated-p (selected-window)))
519 ;; This is a special buffer's frame
520 (iconify-frame (selected-frame))
521 (or (window-dedicated-p (selected-window))
523 (choose-completion-string (extent-string extent)
525 completion-base-size))
527 ;; Delete the longest partial match for STRING
528 ;; that can be found before POINT.
529 (defun choose-completion-delete-max-match (string)
530 (let ((len (min (length string)
531 (- (point) (point-min)))))
532 (goto-char (- (point) (length string)))
533 (if completion-ignore-case
534 (setq string (downcase string)))
535 (while (and (> len 0)
536 (let ((tail (buffer-substring (point)
538 (if completion-ignore-case
539 (setq tail (downcase tail)))
540 (not (string= tail (substring string 0 len)))))
545 ;; Switch to BUFFER and insert the completion choice CHOICE.
546 ;; BASE-SIZE, if non-nil, says how many characters of BUFFER's text
547 ;; to keep. If it is nil, use choose-completion-delete-max-match instead.
548 (defun choose-completion-string (choice &optional buffer base-size)
549 (let ((buffer (or buffer completion-reference-buffer)))
550 ;; If BUFFER is a minibuffer, barf unless it's the currently
551 ;; active minibuffer.
552 (if (and (string-match "\\` \\*Minibuf-[0-9]+\\*\\'" (buffer-name buffer))
553 (or (not (active-minibuffer-window))
555 (window-buffer (active-minibuffer-window))))))
556 (error "Minibuffer is not active for completion")
557 ;; Insert the completion into the buffer where completion was requested.
560 (delete-region (+ base-size (point-min)) (point))
561 (choose-completion-delete-max-match choice))
563 (remove-text-properties (- (point) (length choice)) (point)
565 ;; Update point in the window that BUFFER is showing in.
566 (let ((window (get-buffer-window buffer t)))
567 (set-window-point window (point)))
568 ;; If completing for the minibuffer, exit it with this choice.
569 (and (equal buffer (window-buffer (minibuffer-window)))
570 minibuffer-completion-table
571 (exit-minibuffer)))))
573 (define-key minibuffer-local-completion-map [prior]
574 'switch-to-completions)
575 (define-key minibuffer-local-must-match-map [prior]
576 'switch-to-completions)
577 (define-key minibuffer-local-completion-map "\M-v"
578 'advertised-switch-to-completions)
579 (define-key minibuffer-local-must-match-map "\M-v"
580 'advertised-switch-to-completions)
582 (defalias 'advertised-switch-to-completions 'switch-to-completions)
583 (defun switch-to-completions ()
584 "Select the completion list window."
586 ;; Make sure we have a completions window.
587 (or (get-buffer-window "*Completions*")
588 (minibuffer-completion-help))
589 (if (not (get-buffer-window "*Completions*"))
591 (select-window (get-buffer-window "*Completions*"))
592 (goto-char (next-single-property-change (point-min) 'list-mode-item nil
595 ;;; list-mode.el ends here