:group 'next-error
:version "22.1")
-(defcustom next-error-highlight 0.1
+(defcustom next-error-highlight 0.5
"*Highlighting of locations in selected source buffers.
If number, highlight the locus in `next-error' face for given time in seconds.
-If t, use persistent overlays fontified in `next-error' face.
+If t, highlight the locus indefinitely until some other locus replaces it.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
- :type '(choice (number :tag "Delay")
- (const :tag "Persistent overlay" t)
+ :type '(choice (number :tag "Highlight for specified time")
+ (const :tag "Semipermanent highlighting" t)
(const :tag "No highlighting" nil)
- (const :tag "Fringe arrow" 'fringe-arrow))
+ (const :tag "Fringe arrow" fringe-arrow))
:group 'next-error
:version "22.1")
-(defcustom next-error-highlight-no-select 0.1
- "*Highlighting of locations in non-selected source buffers.
+(defcustom next-error-highlight-no-select 0.5
+ "*Highlighting of locations in `next-error-no-select'.
If number, highlight the locus in `next-error' face for given time in seconds.
-If t, use persistent overlays fontified in `next-error' face.
+If t, highlight the locus indefinitely until some other locus replaces it.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
- :type '(choice (number :tag "Delay")
- (const :tag "Persistent overlay" t)
+ :type '(choice (number :tag "Highlight for specified time")
+ (const :tag "Semipermanent highlighting" t)
(const :tag "No highlighting" nil)
- (const :tag "Fringe arrow" 'fringe-arrow))
+ (const :tag "Fringe arrow" fringe-arrow))
:group 'next-error
:version "22.1")
(defun line-number-at-pos (&optional pos)
"Return (narrowed) buffer line number at position POS.
-If POS is nil, use current buffer location."
+If POS is nil, use current buffer location.
+Counting starts at (point-min), so the value refers
+to the contents of the accessible portion of the buffer."
(let ((opoint (or pos (point))) start)
(save-excursion
(goto-char (point-min))
(format " (#o%o, #x%x)" value value)))))
;; We define this, rather than making `eval' interactive,
-;; for the sake of completion of names like eval-region, eval-current-buffer.
+;; for the sake of completion of names like eval-region, eval-buffer.
(defun eval-expression (eval-expression-arg
&optional eval-expression-insert-value)
"Evaluate EVAL-EXPRESSION-ARG and print value in the echo area.
\(That convention is designed to do the right thing for
recursive uses of the minibuffer.)")
(setq minibuffer-history-variable 'minibuffer-history)
-(setq minibuffer-history-position nil)
+(setq minibuffer-history-position nil) ;; Defvar is in C code.
(defvar minibuffer-history-search-history nil)
(defvar minibuffer-text-before-history nil
'(0 . 0)))
'(0 . 0)))
-(defcustom undo-ask-before-discard t
+(defcustom undo-ask-before-discard nil
"If non-nil ask about discarding undo info for the current command.
Normally, Emacs discards the undo info for the current command if
it exceeds `undo-outer-limit'. But if you set this option
In Lisp code, optional third arg YANK-HANDLER, if non-nil,
specifies the yank-handler text property to be set on the killed
text. See `insert-for-yank'."
- (interactive "r")
+ ;; Pass point first, then mark, because the order matters
+ ;; when calling kill-append.
+ (interactive (list (point) (mark)))
+ (unless (and beg end)
+ (error "The mark is not set now, so there is no region"))
(condition-case nil
(let ((string (filter-buffer-substring beg end t)))
(when string ;STRING is nil if BEG = END
;; This is actually used in subr.el but defcustom does not work there.
(defcustom yank-excluded-properties
'(read-only invisible intangible field mouse-face help-echo local-map keymap
- yank-handler follow-link)
+ yank-handler follow-link fontified)
"*Text properties to discard when yanking.
The value should be a list of text properties to discard or t,
which means to discard all text properties."
(or (memq prop buffer-invisibility-spec)
(assq prop buffer-invisibility-spec)))))
+;; Returns non-nil if partial move was done.
+(defun line-move-partial (arg noerror to-end)
+ (if (< arg 0)
+ ;; Move backward (up).
+ ;; If already vscrolled, reduce vscroll
+ (let ((vs (window-vscroll nil t)))
+ (when (> vs (frame-char-height))
+ (set-window-vscroll nil (- vs (frame-char-height)) t)))
+
+ ;; Move forward (down).
+ (let* ((lh (window-line-height -1))
+ (vpos (nth 1 lh))
+ (ypos (nth 2 lh))
+ (rbot (nth 3 lh))
+ ppos py vs)
+ (when (or (null lh)
+ (>= rbot (frame-char-height))
+ (<= ypos (- (frame-char-height))))
+ (unless lh
+ (let ((wend (pos-visible-in-window-p t nil t)))
+ (setq rbot (nth 3 wend)
+ vpos (nth 5 wend))))
+ (cond
+ ;; If last line of window is fully visible, move forward.
+ ((or (null rbot) (= rbot 0))
+ nil)
+ ;; If cursor is not in the bottom scroll margin, move forward.
+ ((and (> vpos 0)
+ (< (setq py
+ (or (nth 1 (window-line-height))
+ (let ((ppos (posn-at-point)))
+ (cdr (or (posn-actual-col-row ppos)
+ (posn-col-row ppos))))))
+ (min (- (window-text-height) scroll-margin 1) (1- vpos))))
+ nil)
+ ;; When already vscrolled, we vscroll some more if we can,
+ ;; or clear vscroll and move forward at end of tall image.
+ ((> (setq vs (window-vscroll nil t)) 0)
+ (when (> rbot 0)
+ (set-window-vscroll nil (+ vs (min rbot (frame-char-height))) t)))
+ ;; If cursor just entered the bottom scroll margin, move forward,
+ ;; but also vscroll one line so redisplay wont recenter.
+ ((and (> vpos 0)
+ (= py (min (- (window-text-height) scroll-margin 1)
+ (1- vpos))))
+ (set-window-vscroll nil (frame-char-height) t)
+ (line-move-1 arg noerror to-end)
+ t)
+ ;; If there are lines above the last line, scroll-up one line.
+ ((> vpos 0)
+ (scroll-up 1)
+ t)
+ ;; Finally, start vscroll.
+ (t
+ (set-window-vscroll nil (frame-char-height) t)))))))
+
+
;; This is like line-move-1 except that it also performs
;; vertical scrolling of tall images if appropriate.
;; That is not really a clean thing to do, since it mixes
;; a cleaner solution to the problem of making C-n do something
;; useful given a tall image.
(defun line-move (arg &optional noerror to-end try-vscroll)
- (if (and auto-window-vscroll try-vscroll
- ;; But don't vscroll in a keyboard macro.
- (not defining-kbd-macro)
- (not executing-kbd-macro))
- (let ((forward (> arg 0))
- (part (nth 2 (pos-visible-in-window-p (point) nil t))))
- (if (and (consp part)
- (> (if forward (cdr part) (car part)) 0))
- (set-window-vscroll nil
- (if forward
- (+ (window-vscroll nil t)
- (min (cdr part)
- (* (frame-char-height) arg)))
- (max 0
- (- (window-vscroll nil t)
- (min (car part)
- (* (frame-char-height) (- arg))))))
- t)
- (set-window-vscroll nil 0)
- (when (line-move-1 arg noerror to-end)
- (when (not forward)
- ;; Update display before calling pos-visible-in-window-p,
- ;; because it depends on window-start being up-to-date.
- (sit-for 0)
- ;; If the current line is partly hidden at the bottom,
- ;; scroll it partially up so as to unhide the bottom.
- (if (and (setq part (nth 2 (pos-visible-in-window-p
- (line-beginning-position) nil t)))
- (> (cdr part) 0))
- (set-window-vscroll nil (cdr part) t)))
- t)))
+ (unless (and auto-window-vscroll try-vscroll
+ ;; Only vscroll for single line moves
+ (= (abs arg) 1)
+ ;; But don't vscroll in a keyboard macro.
+ (not defining-kbd-macro)
+ (not executing-kbd-macro)
+ (line-move-partial arg noerror to-end))
+ (set-window-vscroll nil 0 t)
(line-move-1 arg noerror to-end)))
;; This is the guts of next-line and previous-line.
;; for intermediate positions.
(let ((inhibit-point-motion-hooks t)
(opoint (point))
- (forward (> arg 0)))
+ (orig-arg arg))
(unwind-protect
(progn
(if (not (memq last-command '(next-line previous-line)))
(if (and track-eol (eolp)
;; Don't count beg of empty line as end of line
;; unless we just did explicit end-of-line.
- (or (not (bolp)) (eq last-command 'end-of-line)))
+ (or (not (bolp)) (eq last-command 'move-end-of-line)))
9999
(current-column))))
'end-of-buffer)
nil)))
;; Move by arg lines, but ignore invisible ones.
- (let (done)
+ (let (done line-end)
(while (and (> arg 0) (not done))
;; If the following character is currently invisible,
;; skip all characters with that same `invisible' property value.
(while (and (not (eobp)) (line-move-invisible-p (point)))
(goto-char (next-char-property-change (point))))
- ;; Now move a line.
- (end-of-line)
+ ;; Move a line.
+ ;; We don't use `end-of-line', since we want to escape
+ ;; from field boundaries ocurring exactly at point.
+ (let ((inhibit-field-text-motion t))
+ (setq line-end (line-end-position)))
+ (goto-char (constrain-to-field line-end (point) t t))
+ ;; When moving a single line, update the goal-column
+ ;; if we couldn't move to the end of line due to a
+ ;; field boundary. Otherwise we'll get stuck at the
+ ;; original position during the column motion in
+ ;; line-move-finish.
+ (and (/= line-end (point))
+ (= orig-arg 1)
+ (setq temporary-goal-column
+ (max temporary-goal-column (current-column))))
;; If there's no invisibility here, move over the newline.
(cond
((eobp)
(beginning-of-line))
(t
(line-move-finish (or goal-column temporary-goal-column)
- opoint forward))))))
+ opoint (> orig-arg 0)))))))
(defun line-move-finish (column opoint forward)
(let ((repeat t))
(setq new (point))
;; Process intangibility within a line.
- ;; Move to the chosen destination position from above,
- ;; with intangibility processing enabled.
-
- (goto-char (point-min))
+ ;; With inhibit-point-motion-hooks bound to nil, a call to
+ ;; goto-char moves point past intangible text.
+
+ ;; However, inhibit-point-motion-hooks controls both the
+ ;; intangibility and the point-entered/point-left hooks. The
+ ;; following hack avoids calling the point-* hooks
+ ;; unnecessarily. Note that we move *forward* past intangible
+ ;; text when the initial and final points are the same.
+ (goto-char new)
(let ((inhibit-point-motion-hooks nil))
(goto-char new)
(goto-char opoint)
(let ((inhibit-point-motion-hooks nil))
(goto-char
- (constrain-to-field new opoint nil t
+ (constrain-to-field new opoint t t
'inhibit-line-move-field-capture)))
;; If all this moved us to a different line,
(interactive "p")
(or arg (setq arg 1))
- (let ((orig (point)))
+ (let ((orig (point))
+ start first-vis first-vis-field-value)
;; Move by lines, if ARG is not 1 (the default).
(if (/= arg 1)
(while (and (not (bobp)) (line-move-invisible-p (1- (point))))
(goto-char (previous-char-property-change (point)))
(skip-chars-backward "^\n"))
+ (setq start (point))
+
+ ;; Now find first visible char in the line
+ (while (and (not (eobp)) (line-move-invisible-p (point)))
+ (goto-char (next-char-property-change (point))))
+ (setq first-vis (point))
- ;; Take care of fields.
- (goto-char (constrain-to-field (point) orig
- (/= arg 1) t nil))))
+ ;; See if fields would stop us from reaching FIRST-VIS.
+ (setq first-vis-field-value
+ (constrain-to-field first-vis orig (/= arg 1) t nil))
+
+ (goto-char (if (/= first-vis-field-value first-vis)
+ ;; If yes, obey them.
+ first-vis-field-value
+ ;; Otherwise, move to START with attention to fields.
+ ;; (It is possible that fields never matter in this case.)
+ (constrain-to-field (point) orig
+ (/= arg 1) t nil)))))
;;; Many people have said they rarely use this feature, and often type
string)
:group 'fill)
(make-variable-buffer-local 'fill-prefix)
+;;;###autoload(put 'fill-prefix 'safe-local-variable 'string-or-null-p)
(defcustom auto-fill-inhibit-regexp nil
"*Regexp to match lines which should not be auto-filled."
(defvaralias 'indicate-unused-lines 'indicate-empty-lines)
(defvaralias 'default-indicate-unused-lines 'default-indicate-empty-lines)
-(defun toggle-truncate-lines (arg)
+(defun toggle-truncate-lines (&optional arg)
"Toggle whether to fold or truncate long lines on the screen.
With arg, truncate long lines iff arg is positive.
Note that in side-by-side windows, truncation is always enabled."
Line numbers do not appear for very large buffers and buffers
with very long lines; see variables `line-number-display-limit'
and `line-number-display-limit-width'."
- :init-value t :global t :group 'editing-basics)
+ :init-value t :global t :group 'mode-line)
(define-minor-mode column-number-mode
"Toggle Column Number mode.
With arg, turn Column Number mode on iff arg is positive.
When Column Number mode is enabled, the column number appears
in the mode line."
- :global t :group 'editing-basics)
+ :global t :group 'mode-line)
(define-minor-mode size-indication-mode
"Toggle Size Indication mode.
With arg, turn Size Indication mode on iff arg is positive. When
Size Indication mode is enabled, the size of the accessible part
of the buffer appears in the mode line."
- :global t :group 'editing-basics)
+ :global t :group 'mode-line)
\f
(defgroup paren-blinking nil
"Blinking matching of parens and expressions."
;; Variables and faces used in `completion-setup-function'.
+(defcustom completion-show-help t
+ "Non-nil means show help message in *Completions* buffer."
+ :type 'boolean
+ :version "22.1"
+ :group 'completion)
+
(defface completions-first-difference
'((t (:inherit bold)))
"Face put on the first uncommon character in completions in *Completions* buffer."
(if (get-char-property element-common-end 'mouse-face)
(put-text-property element-common-end (1+ element-common-end)
'font-lock-face 'completions-first-difference))))))
- ;; Insert help string.
- (goto-char (point-min))
- (if (display-mouse-p)
- (insert (substitute-command-keys
- "Click \\[mouse-choose-completion] on a completion to select it.\n")))
- (insert (substitute-command-keys
- "In this buffer, type \\[choose-completion] to \
-select the completion near point.\n\n")))))
+ ;; Maybe insert help string.
+ (when completion-show-help
+ (goto-char (point-min))
+ (if (display-mouse-p)
+ (insert (substitute-command-keys
+ "Click \\[mouse-choose-completion] on a completion to select it.\n")))
+ (insert (substitute-command-keys
+ "In this buffer, type \\[choose-completion] to \
+select the completion near point.\n\n"))))))
(add-hook 'completion-setup-hook 'completion-setup-function)