* lisp/files.el (auto-narrow-mode): New minor mode.
(auto-narrow-pre-command-function, auto-narrow-post-command-function):
New auxiliary functions for the minor mode.
(auto-narrow-display-length, auto-narrow-widen-automatically): New
defcustoms for the minor mode.
(auto-narrow--widen-automatically, auto-narrow--isearch-widen-automatically,
auto-narrow--initialized): New internal variables for the minor mode.
* src/buffer.h (struct buffer): New internal variable for the minor mode.
(bset_auto_narrow__narrowing_state, BUFFER_AUTO_NARROWED_P): New
auxiliary functions.
* src/buffer.c (init_buffer_once, syms_of_buffer): New internal variable
for the minor mode. Update the docstring of mode-line-format.
* src/fileio.c (Finsert_file_contents): Detect whether the minor mode should
be entered when the buffer is displayed.
(syms_of_fileio): New defcustom for the minor mode.
* src/keyboard.c (syms_of_keyboard): New hook functions for the minor mode.
(command_loop_1): Execute the hook functions.
* src/xdisp.c (redisplay_window): Enter the minor mode when the buffer is
displayed.
(decode_mode_spec): Indicate when the minor mode is active
in the modeline. Indicate the buffer position relative to the whole buffer.
(set_vertical_scroll_bar): Indicate the buffer position relative to the
whole buffer.
(syms_of_xdisp): Two new symbols.
* lisp/isearch.el (isearch-widen-automatically): New defcustom.
(isearch-search): Use the new defcustom.
* lisp/bindings.el (mode-line-modes): Do not propertize the indication
in the modeline when the new minor mode is active.
* etc/NEWS: Announce the new minor mode, and remove the unobsoletion
indication for 'longlines-mode'.
* lisp/longlines.el: Reobsolete longlines-mode.
* doc/emacs/display.texi (Auto-Narrowing): New section, describing the new
minor mode.
(Display): Entry for the new section.
* doc/emacs/trouble.texi (Long Lines): Remove the section.
(Lossage): Remove the entry for the Long Lines section.
* doc/emacs/emacs.texi (Top): Remove the entry for the Long Lines section.
* Horizontal Scrolling:: Moving text left and right in a window.
* Narrowing:: Restricting display and editing to a portion
of the buffer.
+* Auto-Narrowing:: Automatically restrict display to a portion of
+ the buffer.
* View Mode:: Viewing read-only buffers.
* Follow Mode:: Follow mode lets two windows scroll as one.
* Faces:: How to change the display style using faces.
if you enable the command, confirmation will no longer be required for
it. @xref{Disabling}.
+@node Auto-Narrowing
+@findex auto-narrow-mode
+@vindex auto-narrow-long-line-threshold
+@vindex auto-narrow-display-length
+@vindex auto-narrow-widen-automatically
+
+ When a file with extremely long lines is opened or inserted in a
+buffer, Emacs automatically enters auto-narrow mode, and the word
+@samp{Auto-Narrow} appears in the mode line. This means that Emacs
+restricts display, but not editing, to a portion of the buffer above
+and below point. All editing commands, including narrowing commands,
+remain available, and they act on the whole buffer. For example,
+@kbd{M->} moves point to the end of the buffer, and not, as would
+happen with ordinary narrowing, to the end of the portion of the
+buffer to which display is currently restricted.
+
+ The behavior of auto-narrow mode is controlled by three variables:
+@code{auto-narrow-long-line-threshold} is the line length above which
+auto-narrow move is entered, @code{auto-narrow-display-length} is the
+number of characters to which display is restricted, and
+@code{auto-narrow-widen-automatically} is a list of commands for which
+display is widened before they are executed.
+
@node View Mode
@section View Mode
@cindex View mode
* Crashing:: What Emacs does when it crashes.
* After a Crash:: Recovering editing in an Emacs session that crashed.
* Emergency Escape:: What to do if Emacs stops responding.
-* Long Lines:: Mitigating slowness due to extremely long lines.
* DEL Does Not Delete:: What to do if @key{DEL} doesn't delete.
Reporting Bugs
* Crashing:: What Emacs does when it crashes.
* After a Crash:: Recovering editing in an Emacs session that crashed.
* Emergency Escape:: What to do if Emacs stops responding.
-* Long Lines:: Mitigating slowness due to extremely long lines.
* DEL Does Not Delete:: What to do if @key{DEL} doesn't delete.
@end menu
emergency escape---but there are cases where it won't work, when a
system call hangs or when Emacs is stuck in a tight loop in C code.
-@node Long Lines
-@subsection Long Lines
-@cindex long lines
-
- For a variety of reasons (some of which are fundamental to the Emacs
-redisplay code and the complex range of possibilities it handles;
-others of which are due to modes and features which do not scale well
-in unusual circumstances), Emacs can perform poorly when extremely
-long lines are present (where ``extremely long'' usually means at
-least many thousands of characters).
-
-@cindex @code{so-long} mode
-@findex global-so-long-mode
-@vindex so-long-action
- A particular problem is that Emacs may ``hang'' for a long time at
-the point of visiting a file with extremely long lines. This can be
-mitigated by enabling the @file{so-long} library, which detects when a
-visited file contains abnormally long lines, and takes steps to
-disable features which are liable to cause slowness in that situation.
-To enable this library, type @kbd{M-x global-so-long-mode @key{RET}},
-or turn on the @code{global-so-long-mode} in your init file
-(@pxref{Init File}), or customize the @code{global-so-long-mode}
-option. You can tailor this mode's operation by customizing the
-variable @code{so-long-action}.
-
- The @file{so-long} library can also significantly improve
-performance when moving and editing in a buffer with long lines.
-Performance is still likely to degrade as you get deeper into the long
-lines, but the improvements from using this library can nevertheless
-be substantial.
-
-@findex so-long-commentary
- Use @kbd{M-x so-long-commentary} to view the documentation for this
-library and learn more about how to enable and configure it.
-
-@vindex max-redisplay-ticks
- If even @code{so-long-mode} doesn't help making Emacs responsive
-enough, or if you'd rather not disable the display-related features
-that @code{so-long-mode} turns off, you can instead customize the
-variable @code{max-redisplay-ticks} to a non-zero value. Then Emacs
-will abort redisplay of a window and commands, like @kbd{C-n} and
-@kbd{M-v}, which use the display code to do their job, if processing a
-window needs more low-level display operations than the value of this
-variable. The display of the offending window will then remain
-outdated, and possibly incomplete, on the screen, but Emacs should
-otherwise be responsive, and you could then switch to another buffer,
-or kill the problematic buffer, or turn on @code{so-long-mode} or
-@code{so-long-minor-mode} in that buffer. When the display of a
-window is aborted due to this reason, the buffer shown in that window
-will not have any of its windows redisplayed until the buffer is
-modified or until you type @kbd{C-l} (@pxref{Recentering}) in one of
-that buffer's windows.
-
- If you decide to customize this variable to a non-zero value, we
-recommend to use a value between 100,000 and 1,000,000, depending on
-your patience and the speed of your system. The default value is
-zero, which disables this feature.
-
@node DEL Does Not Delete
@subsection If @key{DEL} Fails to Delete
@cindex @key{DEL} vs @key{BACKSPACE}
\f
* Changes in Emacs 29.1
----
-** 'longlines-mode' is no longer obsolete.
-
+++
** New command to change the font size globally.
To increase the font size, type 'C-x C-M-+' or 'C-x C-M-='; to
'cycle-spacing' and their order can now be customized via the user
option 'cycle-spacing-actions'.
++++
+** Emacs is now capable of editing files with arbitarily long lines.
+When a file with long lines is opened or inserted in a buffer, Emacs
+automatically enters auto-narrow mode. This means that Emacs
+restricts display, but not editing, to a portion of the buffer above
+and below point. All editing commands, including narrowing commands,
+remain available, and they act on the whole buffer. The behavior of
+that mode is controlled by three variables:
+auto-narrow-long-line-threshold, auto-narrow-display-length and
+auto-narrow-widen-automatically. To disable that feature, set
+auto-narrow-long-line-threshold to nil in your init file.
+
---
** 'zap-to-char' and 'zap-up-to-char' are case-sensitive for upper-case chars.
These commands now behave as case-sensitive for interactive calls when
mouse-2: Show help for minor mode\n\
mouse-3: Toggle minor modes"
local-map ,mode-line-minor-mode-keymap)
- (propertize "%n" 'help-echo "mouse-2: Remove narrowing from buffer"
- 'mouse-face 'mode-line-highlight
- 'local-map (make-mode-line-mouse-map
- 'mouse-2 #'mode-line-widen))
+ '(:eval
+ (if (not (eq auto-narrow--narrowing-state 'auto))
+ (propertize "%n"
+ 'help-echo "mouse-2: Remove narrowing from buffer"
+ 'mouse-face 'mode-line-highlight
+ 'local-map (make-mode-line-mouse-map
+ 'mouse-2 #'mode-line-widen))
+ "%n"))
")"
(propertize "%]" 'help-echo recursive-edit-help-echo)
" "))
(confirm-nonexistent-file-or-buffer))))
(switch-to-buffer (find-file-noselect filename nil t)))
\f
+(defcustom auto-narrow-display-length 30000
+ "Number of characters to which display is restricted in `auto-narrow-mode'.
+
+When `auto-narrow-mode' is in effect, the number of characters
+displayed above and below point is one third of
+`auto-narrow-display-line-length', except at the beginning and
+end of the buffer."
+ :group 'files
+ :group 'find-file
+ :version "29.1"
+ :type 'integer)
+
+(defcustom auto-narrow-widen-automatically
+ '( move-beginning-of-line move-end-of-line backward-sentence forward-sentence
+ backward-sexp forward-sexp beginning-of-defun end-of-defun
+ beginning-of-buffer end-of-buffer goto-char goto-line
+ mark-sexp mark-defun mark-paragraph mark-whole-buffer mark-page
+ exchange-point-and-mark pop-global-mark set-mark-command jump-to-register
+ bookmark-jump)
+ "Commands for which display is automatically widened in `auto-narrow-mode'."
+ :group 'files
+ :group 'find-file
+ :version "29.1"
+ :type '(repeat function))
+
+(defvar-local auto-narrow--widen-automatically nil
+ "Internal variable used by `auto-narrow-mode'.")
+
+(defvar-local auto-narrow--isearch-widen-automatically nil
+ "Internal variable used by `auto-narrow-mode'.")
+
+(defvar-local auto-narrow--initialized nil
+ "Internal variable used by `auto-narrow-mode'.")
+
+(defun auto-narrow-pre-command-function ()
+ "Conditionally widen display when `auto-narrow-mode' is in effect."
+ (when auto-narrow-mode
+ (unless auto-narrow--initialized
+ (setq auto-narrow--widen-automatically widen-automatically
+ auto-narrow--isearch-widen-automatically isearch-widen-automatically
+ auto-narrow--narrowing-state 'auto
+ auto-narrow--initialized t))
+ (setq-local widen-automatically t
+ isearch-widen-automatically t)
+ (if (memq this-command '(narrow-to-region narrow-to-defun narrow-to-page))
+ (setq auto-narrow--narrowing-state 'explicit
+ widen-automatically auto-narrow--widen-automatically
+ isearch-widen-automatically auto-narrow--isearch-widen-automatically))
+ (if (eq this-command 'widen)
+ (setq auto-narrow--narrowing-state 'auto))
+ (when (and (not (eq auto-narrow--narrowing-state 'explicit))
+ (memq this-command auto-narrow-widen-automatically))
+ (widen))))
+
+(defun auto-narrow-post-command-function ()
+ "Update display narrowing when `auto-narrow-mode' is in effect."
+ (when (and auto-narrow-mode
+ (not (eq auto-narrow--narrowing-state 'explicit)))
+ (unless auto-narrow--initialized
+ (setq auto-narrow--narrowing-state 'auto))
+ (let (point cur-point-min buf-point-min buf-point-max size)
+ (setq point (point) cur-point-min (point-min)
+ size (/ auto-narrow-display-length 3))
+ (save-restriction
+ (widen)
+ (setq buf-point-min (point-min) buf-point-max (point-max)))
+ (let* ((pos (* (min (max (/ point size) 1)
+ (1- (/ buf-point-max size)))
+ size))
+ (begin (max (- pos size) buf-point-min))
+ (end (min (+ begin (* 3 size)) buf-point-max)))
+ (when (or (not (buffer-narrowed-p))
+ (not (= begin cur-point-min)))
+ (narrow-to-region begin end))))))
+
+(setq auto-narrow-long-line-threshold 30000
+ auto-narrow-pre-command-function #'auto-narrow-pre-command-function
+ auto-narrow-post-command-function #'auto-narrow-post-command-function)
+
+(define-minor-mode auto-narrow-mode
+ "Automatically narrow the display of a buffer above and below point.
+
+This mode is automatically entered when a file with one or more lines
+longer than `auto-narrow-long-line-threshold' is opened or inserted
+in a buffer. It restricts display, but not editing, to
+`auto-narrow-display-length' characters. Display is widened before
+executing any of the commands listed in `auto-narrow-widen-automatically'."
+ :group 'files
+ :version "29.1"
+ :after-hook (progn (put 'auto-narrow-mode 'permanent-local t))
+ (if auto-narrow-mode
+ (auto-narrow-post-command-function)
+ (when (not (eq auto-narrow--narrowing-state 'explicit))
+ (widen))
+ (setq auto-narrow--narrowing-state nil
+ auto-narrow--initialized nil)))
+\f
(defun after-find-file (&optional error warn noauto
_after-find-file-from-revert-buffer
nomodes)
:type 'boolean
:group 'isearch)
+(defcustom isearch-widen-automatically nil
+ "Whether a narrowed buffer can be widened when isearch fails.
+This option has no effect when `widen-automatically' is nil."
+ :version "29.1"
+ :type 'boolean
+ :group 'isearch)
+
(defun isearch-string-out-of-window (isearch-point)
"Test whether the search string is currently outside of the window.
Return nil if it's completely visible, or if point is visible,
(while retry
(setq isearch-success
(isearch-search-string isearch-string nil t))
- ;; Clear RETRY unless the search predicate says
- ;; to skip this search hit.
- (if (or (not isearch-success)
- (funcall isearch-filter-predicate
- (match-beginning 0) (match-end 0)))
- (setq retry nil)
- ;; Advance point on empty matches before retrying
- (when (= (match-beginning 0) (match-end 0))
- (if (if isearch-forward (eobp) (bobp))
- (setq retry nil isearch-success nil)
- (forward-char (if isearch-forward 1 -1))))))
+ (if (and (not isearch-success) (buffer-narrowed-p)
+ isearch-widen-automatically widen-automatically)
+ (widen)
+ ;; Clear RETRY unless the search predicate says
+ ;; to skip this search hit.
+ (if (or (not isearch-success)
+ (funcall isearch-filter-predicate
+ (match-beginning 0) (match-end 0)))
+ (setq retry nil)
+ ;; Advance point on empty matches before retrying
+ (when (= (match-beginning 0) (match-end 0))
+ (if (if isearch-forward (eobp) (bobp))
+ (setq retry nil isearch-success nil)
+ (forward-char (if isearch-forward 1 -1)))))))
(setq isearch-just-started nil)
(when isearch-success
(setq isearch-other-end
+++ /dev/null
-;;; longlines.el --- automatically wrap long lines -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2000-2001, 2004-2022 Free Software Foundation, Inc.
-
-;; Authors: Kai Grossjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE>
-;; Alex Schroeder <alex@gnu.org>
-;; Chong Yidong <cyd@stupidchicken.com>
-;; Maintainer: emacs-devel@gnu.org
-;; Keywords: convenience, wp
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; Some text editors save text files with long lines, and they
-;; automatically break these lines at whitespace, without actually
-;; inserting any newline characters. When doing `M-q' in Emacs, you
-;; are inserting newline characters. Longlines mode provides a file
-;; format which wraps the long lines when reading a file and unwraps
-;; the lines when saving the file. It can also wrap and unwrap
-;; automatically as editing takes place.
-
-;; Special thanks to Rod Smith for many useful bug reports.
-
-;;; Code:
-;;; Options
-
-(defgroup longlines nil
- "Automatic wrapping of long lines when loading files."
- :group 'fill)
-
-(defcustom longlines-auto-wrap t
- "Non-nil means long lines are automatically wrapped after each command.
-Otherwise, you can perform filling using `fill-paragraph' or
-`auto-fill-mode'. In any case, the soft newlines will be removed
-when the file is saved to disk."
- :type 'boolean)
-
-(defcustom longlines-wrap-follows-window-size nil
- "Non-nil means wrapping and filling happen at the edge of the window.
-Otherwise, `fill-column' is used, regardless of the window size. This
-does not work well when the buffer is displayed in multiple windows
-with differing widths.
-
-If the value is an integer, that specifies the distance from the
-right edge of the window at which wrapping occurs. For any other
-non-nil value, wrapping occurs 2 characters from the right edge."
- :type 'boolean)
-
-(defcustom longlines-show-hard-newlines nil
- "Non-nil means each hard newline is marked on the screen.
-\(The variable `longlines-show-effect' controls what they look like.)
-You can also enable the display temporarily, using the command
-`longlines-show-hard-newlines'."
- :type 'boolean)
-
-(defcustom longlines-show-effect (propertize "¶\n" 'face 'escape-glyph)
- "A string to display when showing hard newlines.
-This is used when `longlines-show-hard-newlines' is on."
- :type 'string)
-
-(defcustom longlines-breakpoint-chars " ;,|"
- "A bag of separator chars for longlines."
- :type 'string)
-
-;;; Internal variables
-
-(defvar longlines-wrap-beg nil)
-(defvar longlines-wrap-end nil)
-(defvar longlines-wrap-point nil)
-(defvar longlines-showing nil)
-(defvar longlines-decoded nil)
-
-(make-variable-buffer-local 'longlines-wrap-beg)
-(make-variable-buffer-local 'longlines-wrap-end)
-(make-variable-buffer-local 'longlines-wrap-point)
-(make-variable-buffer-local 'longlines-showing)
-(make-variable-buffer-local 'longlines-decoded)
-
-;;; Mode
-
-(defvar message-indent-citation-function)
-
-;;;###autoload
-(define-minor-mode longlines-mode
- "Toggle Long Lines mode in this buffer.
-
-When Long Lines mode is enabled, long lines are wrapped if they
-extend beyond `fill-column'. The soft newlines used for line
-wrapping will not show up when the text is yanked or saved to
-disk.
-
-If the variable `longlines-auto-wrap' is non-nil, lines are
-automatically wrapped whenever the buffer is changed. You can
-always call `fill-paragraph' to fill individual paragraphs.
-
-If the variable `longlines-show-hard-newlines' is non-nil, hard
-newlines are indicated with a symbol."
- :lighter " ll"
- (if longlines-mode
- ;; Turn on longlines mode
- (progn
- (use-hard-newlines 1 'never)
- (set (make-local-variable 'require-final-newline) nil)
- (add-to-list 'buffer-file-format 'longlines)
- (add-hook 'change-major-mode-hook #'longlines-mode-off nil t)
- (add-hook 'before-revert-hook #'longlines-before-revert-hook nil t)
- (make-local-variable 'buffer-substring-filters)
- (make-local-variable 'longlines-auto-wrap)
- (set (make-local-variable 'isearch-search-fun-function)
- #'longlines-search-function)
- (set (make-local-variable 'replace-search-function)
- #'longlines-search-forward)
- (set (make-local-variable 'replace-re-search-function)
- #'longlines-re-search-forward)
- (add-to-list 'buffer-substring-filters 'longlines-encode-string)
- (when longlines-wrap-follows-window-size
- (let ((dw (if (and (integerp longlines-wrap-follows-window-size)
- (>= longlines-wrap-follows-window-size 0)
- (< longlines-wrap-follows-window-size
- (window-width)))
- longlines-wrap-follows-window-size
- 2)))
- (set (make-local-variable 'fill-column)
- (- (window-width) dw)))
- (add-hook 'window-configuration-change-hook
- #'longlines-window-change-function nil t))
- (let ((buffer-undo-list t)
- (inhibit-read-only t)
- (inhibit-modification-hooks t)
- (mod (buffer-modified-p))
- buffer-file-name buffer-file-truename)
- ;; Turning off undo is OK since (spaces + newlines) is
- ;; conserved, except for a corner case in
- ;; longlines-wrap-lines that we'll never encounter from here
- (save-restriction
- (widen)
- (unless longlines-decoded
- (longlines-decode-buffer)
- (setq longlines-decoded t))
- (longlines-wrap-region (point-min) (point-max)))
- (set-buffer-modified-p mod))
- (when (and longlines-show-hard-newlines
- (not longlines-showing))
- (longlines-show-hard-newlines))
-
- ;; Hacks to make longlines play nice with various modes.
- (cond ((eq major-mode 'mail-mode)
- (declare-function mail-indent-citation "sendmail" ())
- (add-hook 'mail-setup-hook #'longlines-decode-buffer nil t)
- (or mail-citation-hook
- (add-hook 'mail-citation-hook #'mail-indent-citation nil t))
- (add-hook 'mail-citation-hook #'longlines-decode-region nil t))
- ((eq major-mode 'message-mode)
- (add-hook 'message-setup-hook #'longlines-decode-buffer nil t)
- (make-local-variable 'message-indent-citation-function)
- (if (not (listp message-indent-citation-function))
- (setq message-indent-citation-function
- (list message-indent-citation-function)))
- (add-hook 'message-indent-citation-function
- #'longlines-decode-region t t)))
-
- (add-hook 'after-change-functions #'longlines-after-change-function nil t)
- (add-hook 'post-command-hook #'longlines-post-command-function nil t)
- (when longlines-auto-wrap
- (auto-fill-mode 0)))
- ;; Turn off longlines mode
- (setq buffer-file-format (delete 'longlines buffer-file-format))
- (if longlines-showing
- (longlines-unshow-hard-newlines))
- (let ((buffer-undo-list t)
- (inhibit-modification-hooks t)
- (inhibit-read-only t)
- buffer-file-name buffer-file-truename)
- (if longlines-decoded
- (save-restriction
- (widen)
- (longlines-encode-region (point-min) (point-max))
- (setq longlines-decoded nil))))
- (remove-hook 'change-major-mode-hook #'longlines-mode-off t)
- (remove-hook 'after-change-functions #'longlines-after-change-function t)
- (remove-hook 'post-command-hook #'longlines-post-command-function t)
- (remove-hook 'before-revert-hook #'longlines-before-revert-hook t)
- (remove-hook 'window-configuration-change-hook
- #'longlines-window-change-function t)
- (when longlines-wrap-follows-window-size
- (kill-local-variable 'fill-column))
- (kill-local-variable 'isearch-search-fun-function)
- (kill-local-variable 'replace-search-function)
- (kill-local-variable 'replace-re-search-function)
- (kill-local-variable 'require-final-newline)
- (kill-local-variable 'buffer-substring-filters)
- (kill-local-variable 'use-hard-newlines)))
-
-(defun longlines-mode-off ()
- "Turn off longlines mode.
-This function exists to be called by `change-major-mode-hook' when the
-major mode changes."
- (longlines-mode 0))
-
-;;; Showing the effect of hard newlines in the buffer
-
-(defun longlines-show-hard-newlines (&optional arg)
- "Make hard newlines visible by adding a face.
-With optional argument ARG, make the hard newlines invisible again."
- (interactive "P")
- (if arg
- (longlines-unshow-hard-newlines)
- (setq longlines-showing t)
- (longlines-show-region (point-min) (point-max))))
-
-(defun longlines-show-region (beg end)
- "Make hard newlines between BEG and END visible."
- (let* ((pmin (min beg end))
- (pmax (max beg end))
- (pos (text-property-not-all pmin pmax 'hard nil))
- (mod (buffer-modified-p))
- (buffer-undo-list t)
- (inhibit-read-only t)
- (inhibit-modification-hooks t)
- buffer-file-name buffer-file-truename)
- (while pos
- (put-text-property pos (1+ pos) 'display
- (copy-sequence longlines-show-effect))
- (setq pos (text-property-not-all (1+ pos) pmax 'hard nil)))
- (restore-buffer-modified-p mod)))
-
-(defun longlines-unshow-hard-newlines ()
- "Make hard newlines invisible again."
- (interactive)
- (setq longlines-showing nil)
- (let ((pos (text-property-not-all (point-min) (point-max) 'hard nil))
- (mod (buffer-modified-p))
- (buffer-undo-list t)
- (inhibit-read-only t)
- (inhibit-modification-hooks t)
- buffer-file-name buffer-file-truename)
- (while pos
- (remove-text-properties pos (1+ pos) '(display nil))
- (setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
- (restore-buffer-modified-p mod)))
-
-;;; Wrapping the paragraphs
-
-(defun longlines-wrap-region (beg end)
- "Wrap each successive line, starting with the line before BEG.
-Stop when we reach lines after END that don't need wrapping, or the
-end of the buffer."
- (let ((mod (buffer-modified-p)))
- (setq longlines-wrap-point (point))
- (goto-char beg)
- (forward-line -1)
- ;; Two successful longlines-wrap-line's in a row mean successive
- ;; lines don't need wrapping.
- (while (null (and (longlines-wrap-line)
- (or (eobp)
- (and (>= (point) end)
- (longlines-wrap-line))))))
- (goto-char longlines-wrap-point)
- (set-buffer-modified-p mod)))
-
-(defun longlines-wrap-line ()
- "If the current line needs to be wrapped, wrap it and return nil.
-If wrapping is performed, point remains on the line. If the line does
-not need to be wrapped, move point to the next line and return t."
- (if (longlines-set-breakpoint fill-column)
- (progn (insert-before-markers-and-inherit ?\n)
- nil)
- (if (longlines-merge-lines-p)
- (progn (end-of-line)
- ;; After certain commands (e.g. kill-line), there may be two
- ;; successive soft newlines in the buffer. In this case, we
- ;; replace these two newlines by a single space. Unfortunately,
- ;; this breaks the conservation of (spaces + newlines), so we
- ;; have to fiddle with longlines-wrap-point.
- (if (or (prog1 (bolp) (forward-char 1)) (eolp))
- (progn
- (delete-char -1)
- (if (> longlines-wrap-point (point))
- (setq longlines-wrap-point
- (1- longlines-wrap-point))))
- (delete-char -1))
- nil)
- (forward-line 1)
- t)))
-
-(defun longlines-set-breakpoint (target-column)
- "Place point where we should break the current line, and return t.
-If the line should not be broken, return nil; point remains on the
-line."
- (move-to-column target-column)
- (let ((non-breakpoint-re (format "[^%s]" longlines-breakpoint-chars)))
- (if (and (re-search-forward non-breakpoint-re (line-end-position) t 1)
- (> (current-column) target-column))
- ;; This line is too long. Can we break it?
- (or (longlines-find-break-backward)
- (progn (move-to-column target-column)
- (longlines-find-break-forward))))))
-
-(defun longlines-find-break-backward ()
- "Move point backward to the first available breakpoint and return t.
-If no breakpoint is found, return nil."
- (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars)))
- (when (and (re-search-backward breakpoint-re (line-beginning-position) t 1)
- (save-excursion
- (skip-chars-backward longlines-breakpoint-chars
- (line-beginning-position))
- (null (bolp))))
- (forward-char 1)
- (if (and fill-nobreak-predicate
- (run-hook-with-args-until-success 'fill-nobreak-predicate))
- (progn
- (skip-chars-backward longlines-breakpoint-chars
- (line-beginning-position))
- (longlines-find-break-backward))
- t))))
-
-(defun longlines-find-break-forward ()
- "Move point forward to the first available breakpoint and return t.
-If no break point is found, return nil."
- (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars)))
- (and (re-search-forward breakpoint-re (line-end-position) t 1)
- (progn
- (skip-chars-forward longlines-breakpoint-chars (line-end-position))
- (null (eolp)))
- (if (and fill-nobreak-predicate
- (run-hook-with-args-until-success 'fill-nobreak-predicate))
- (longlines-find-break-forward)
- t))))
-
-(defun longlines-merge-lines-p ()
- "Return t if part of the next line can fit onto the current line.
-Otherwise, return nil. Text cannot be moved across hard newlines."
- (save-excursion
- (end-of-line)
- (and (null (eobp))
- (null (get-text-property (point) 'hard))
- (let ((space (- fill-column (current-column))))
- (forward-line 1)
- (longlines-set-breakpoint (max 0 (1- space)))))))
-
-(defun longlines-decode-region (&optional beg end)
- "Turn all newlines between BEG and END into hard newlines.
-If BEG and END are nil, the point and mark are used."
- (if (null beg) (setq beg (point)))
- (if (null end) (setq end (mark t)))
- (save-excursion
- (let ((reg-max (max beg end)))
- (goto-char (min beg end))
- (while (search-forward "\n" reg-max t)
- (set-hard-newline-properties
- (match-beginning 0) (match-end 0))))))
-
-(defun longlines-decode-buffer ()
- "Turn all newlines in the buffer into hard newlines."
- (longlines-decode-region (point-min) (point-max)))
-
-(defun longlines-encode-region (beg end &optional _buffer)
- "Remove each soft newline between BEG and END.
-Hard newlines are left intact. The optional argument BUFFER exists for
-compatibility with `format-alist', and is ignored."
- (save-excursion
- (let ((reg-max (max beg end))
- (mod (buffer-modified-p)))
- (goto-char (min beg end))
- (while (search-forward "\n" reg-max t)
- (let ((pos (match-beginning 0)))
- (unless (get-text-property pos 'hard)
- (remove-text-properties pos (1+ pos) '(hard nil))
- (delete-region pos (1+ pos)))))
- (set-buffer-modified-p mod)
- end)))
-
-(defun longlines-encode-string (string)
- "Return a copy of STRING with each soft newline replaced by a space.
-Hard newlines are left intact."
- (let* ((str (copy-sequence string))
- (pos (string-search "\n" str)))
- (while pos
- (if (null (get-text-property pos 'hard str))
- (aset str pos ? ))
- (setq pos (string-search "\n" str (1+ pos))))
- str))
-
-;;; Auto wrap
-
-(defun longlines-auto-wrap (&optional arg)
- "Toggle automatic line wrapping.
-With optional argument ARG, turn on line wrapping if and only if
-ARG is positive.
-If automatic line wrapping is turned on, wrap the entire buffer."
- (interactive "P")
- (setq arg (if arg
- (> (prefix-numeric-value arg) 0)
- (not longlines-auto-wrap)))
- (if arg
- (progn
- (setq longlines-auto-wrap t)
- (longlines-wrap-region (point-min) (point-max))
- (message "Auto wrap enabled."))
- (setq longlines-auto-wrap nil)
- (message "Auto wrap disabled.")))
-
-(defun longlines-after-change-function (beg end _len)
- "Update `longlines-wrap-beg' and `longlines-wrap-end'.
-This is called by `after-change-functions' to keep track of the region
-that has changed."
- (when (and longlines-auto-wrap (not undo-in-progress))
- (setq longlines-wrap-beg
- (if longlines-wrap-beg (min longlines-wrap-beg beg) beg))
- (setq longlines-wrap-end
- (if longlines-wrap-end (max longlines-wrap-end end) end))))
-
-(defun longlines-post-command-function ()
- "Perform line wrapping on the parts of the buffer that have changed.
-This is called by `post-command-hook' after each command."
- (when (and longlines-auto-wrap longlines-wrap-beg)
- (if (or (eq this-command 'yank)
- (eq this-command 'yank-pop))
- (longlines-decode-region (point) (mark t)))
- (if longlines-showing
- (longlines-show-region longlines-wrap-beg longlines-wrap-end))
- (unless (or (eq this-command 'fill-paragraph)
- (eq this-command 'fill-region))
- (longlines-wrap-region longlines-wrap-beg longlines-wrap-end))
- (setq longlines-wrap-beg nil)
- (setq longlines-wrap-end nil)))
-
-(defun longlines-window-change-function ()
- "Re-wrap the buffer if the window width has changed.
-This is called by `window-configuration-change-hook'."
- (let ((dw (if (and (integerp longlines-wrap-follows-window-size)
- (>= longlines-wrap-follows-window-size 0)
- (< longlines-wrap-follows-window-size (window-width)))
- longlines-wrap-follows-window-size
- 2)))
- (when (/= fill-column (- (window-width) dw))
- (setq fill-column (- (window-width) dw))
- (longlines-wrap-region (point-min) (point-max)))))
-
-;;; Isearch
-
-(defun longlines-search-function ()
- (cond
- ((or isearch-regexp-function isearch-regexp) (isearch-search-fun-default))
- (isearch-forward #'longlines-search-forward)
- (t #'longlines-search-backward)))
-
-(defun longlines-search-forward (string &optional bound noerror count)
- (let ((search-spaces-regexp " *[ \n]"))
- (re-search-forward (regexp-quote string) bound noerror count)))
-
-(defun longlines-search-backward (string &optional bound noerror count)
- (let ((search-spaces-regexp " *[ \n]"))
- (re-search-backward (regexp-quote string) bound noerror count)))
-
-(defun longlines-re-search-forward (string &optional bound noerror count)
- (let ((search-spaces-regexp " *[ \n]"))
- (re-search-forward string bound noerror count)))
-
-;;; Loading and saving
-
-(defun longlines-before-revert-hook ()
- (add-hook 'after-revert-hook #'longlines-after-revert-hook nil t)
- (longlines-mode 0))
-
-(defun longlines-after-revert-hook ()
- (remove-hook 'after-revert-hook #'longlines-after-revert-hook t)
- (longlines-mode 1))
-
-(add-to-list
- 'format-alist
- (list 'longlines "Automatically wrap long lines." nil nil
- #'longlines-encode-region t nil))
-
-;;; Unloading
-
-(defun longlines-unload-function ()
- "Unload the longlines library."
- (save-current-buffer
- (dolist (buffer (buffer-list))
- (set-buffer buffer)
- (longlines-mode-off)))
- ;; continue standard unloading
- nil)
-
-(provide 'longlines)
-
-;;; longlines.el ends here
--- /dev/null
+;;; longlines.el --- automatically wrap long lines -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2000-2001, 2004-2022 Free Software Foundation, Inc.
+
+;; Authors: Kai Grossjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE>
+;; Alex Schroeder <alex@gnu.org>
+;; Chong Yidong <cyd@stupidchicken.com>
+;; Maintainer: emacs-devel@gnu.org
+;; Obsolete-since: 24.4
+;; Keywords: convenience, wp
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Some text editors save text files with long lines, and they
+;; automatically break these lines at whitespace, without actually
+;; inserting any newline characters. When doing `M-q' in Emacs, you
+;; are inserting newline characters. Longlines mode provides a file
+;; format which wraps the long lines when reading a file and unwraps
+;; the lines when saving the file. It can also wrap and unwrap
+;; automatically as editing takes place.
+
+;; Special thanks to Rod Smith for many useful bug reports.
+
+;;; Code:
+;;; Options
+
+(defgroup longlines nil
+ "Automatic wrapping of long lines when loading files."
+ :group 'fill)
+
+(defcustom longlines-auto-wrap t
+ "Non-nil means long lines are automatically wrapped after each command.
+Otherwise, you can perform filling using `fill-paragraph' or
+`auto-fill-mode'. In any case, the soft newlines will be removed
+when the file is saved to disk."
+ :type 'boolean)
+
+(defcustom longlines-wrap-follows-window-size nil
+ "Non-nil means wrapping and filling happen at the edge of the window.
+Otherwise, `fill-column' is used, regardless of the window size. This
+does not work well when the buffer is displayed in multiple windows
+with differing widths.
+
+If the value is an integer, that specifies the distance from the
+right edge of the window at which wrapping occurs. For any other
+non-nil value, wrapping occurs 2 characters from the right edge."
+ :type 'boolean)
+
+(defcustom longlines-show-hard-newlines nil
+ "Non-nil means each hard newline is marked on the screen.
+\(The variable `longlines-show-effect' controls what they look like.)
+You can also enable the display temporarily, using the command
+`longlines-show-hard-newlines'."
+ :type 'boolean)
+
+(defcustom longlines-show-effect (propertize "¶\n" 'face 'escape-glyph)
+ "A string to display when showing hard newlines.
+This is used when `longlines-show-hard-newlines' is on."
+ :type 'string)
+
+(defcustom longlines-breakpoint-chars " ;,|"
+ "A bag of separator chars for longlines."
+ :type 'string)
+
+;;; Internal variables
+
+(defvar longlines-wrap-beg nil)
+(defvar longlines-wrap-end nil)
+(defvar longlines-wrap-point nil)
+(defvar longlines-showing nil)
+(defvar longlines-decoded nil)
+
+(make-variable-buffer-local 'longlines-wrap-beg)
+(make-variable-buffer-local 'longlines-wrap-end)
+(make-variable-buffer-local 'longlines-wrap-point)
+(make-variable-buffer-local 'longlines-showing)
+(make-variable-buffer-local 'longlines-decoded)
+
+;;; Mode
+
+(defvar message-indent-citation-function)
+
+;;;###autoload
+(define-minor-mode longlines-mode
+ "Toggle Long Lines mode in this buffer.
+
+When Long Lines mode is enabled, long lines are wrapped if they
+extend beyond `fill-column'. The soft newlines used for line
+wrapping will not show up when the text is yanked or saved to
+disk.
+
+If the variable `longlines-auto-wrap' is non-nil, lines are
+automatically wrapped whenever the buffer is changed. You can
+always call `fill-paragraph' to fill individual paragraphs.
+
+If the variable `longlines-show-hard-newlines' is non-nil, hard
+newlines are indicated with a symbol."
+ :lighter " ll"
+ (if longlines-mode
+ ;; Turn on longlines mode
+ (progn
+ (use-hard-newlines 1 'never)
+ (set (make-local-variable 'require-final-newline) nil)
+ (add-to-list 'buffer-file-format 'longlines)
+ (add-hook 'change-major-mode-hook #'longlines-mode-off nil t)
+ (add-hook 'before-revert-hook #'longlines-before-revert-hook nil t)
+ (make-local-variable 'buffer-substring-filters)
+ (make-local-variable 'longlines-auto-wrap)
+ (set (make-local-variable 'isearch-search-fun-function)
+ #'longlines-search-function)
+ (set (make-local-variable 'replace-search-function)
+ #'longlines-search-forward)
+ (set (make-local-variable 'replace-re-search-function)
+ #'longlines-re-search-forward)
+ (add-to-list 'buffer-substring-filters 'longlines-encode-string)
+ (when longlines-wrap-follows-window-size
+ (let ((dw (if (and (integerp longlines-wrap-follows-window-size)
+ (>= longlines-wrap-follows-window-size 0)
+ (< longlines-wrap-follows-window-size
+ (window-width)))
+ longlines-wrap-follows-window-size
+ 2)))
+ (set (make-local-variable 'fill-column)
+ (- (window-width) dw)))
+ (add-hook 'window-configuration-change-hook
+ #'longlines-window-change-function nil t))
+ (let ((buffer-undo-list t)
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t)
+ (mod (buffer-modified-p))
+ buffer-file-name buffer-file-truename)
+ ;; Turning off undo is OK since (spaces + newlines) is
+ ;; conserved, except for a corner case in
+ ;; longlines-wrap-lines that we'll never encounter from here
+ (save-restriction
+ (widen)
+ (unless longlines-decoded
+ (longlines-decode-buffer)
+ (setq longlines-decoded t))
+ (longlines-wrap-region (point-min) (point-max)))
+ (set-buffer-modified-p mod))
+ (when (and longlines-show-hard-newlines
+ (not longlines-showing))
+ (longlines-show-hard-newlines))
+
+ ;; Hacks to make longlines play nice with various modes.
+ (cond ((eq major-mode 'mail-mode)
+ (declare-function mail-indent-citation "sendmail" ())
+ (add-hook 'mail-setup-hook #'longlines-decode-buffer nil t)
+ (or mail-citation-hook
+ (add-hook 'mail-citation-hook #'mail-indent-citation nil t))
+ (add-hook 'mail-citation-hook #'longlines-decode-region nil t))
+ ((eq major-mode 'message-mode)
+ (add-hook 'message-setup-hook #'longlines-decode-buffer nil t)
+ (make-local-variable 'message-indent-citation-function)
+ (if (not (listp message-indent-citation-function))
+ (setq message-indent-citation-function
+ (list message-indent-citation-function)))
+ (add-hook 'message-indent-citation-function
+ #'longlines-decode-region t t)))
+
+ (add-hook 'after-change-functions #'longlines-after-change-function nil t)
+ (add-hook 'post-command-hook #'longlines-post-command-function nil t)
+ (when longlines-auto-wrap
+ (auto-fill-mode 0)))
+ ;; Turn off longlines mode
+ (setq buffer-file-format (delete 'longlines buffer-file-format))
+ (if longlines-showing
+ (longlines-unshow-hard-newlines))
+ (let ((buffer-undo-list t)
+ (inhibit-modification-hooks t)
+ (inhibit-read-only t)
+ buffer-file-name buffer-file-truename)
+ (if longlines-decoded
+ (save-restriction
+ (widen)
+ (longlines-encode-region (point-min) (point-max))
+ (setq longlines-decoded nil))))
+ (remove-hook 'change-major-mode-hook #'longlines-mode-off t)
+ (remove-hook 'after-change-functions #'longlines-after-change-function t)
+ (remove-hook 'post-command-hook #'longlines-post-command-function t)
+ (remove-hook 'before-revert-hook #'longlines-before-revert-hook t)
+ (remove-hook 'window-configuration-change-hook
+ #'longlines-window-change-function t)
+ (when longlines-wrap-follows-window-size
+ (kill-local-variable 'fill-column))
+ (kill-local-variable 'isearch-search-fun-function)
+ (kill-local-variable 'replace-search-function)
+ (kill-local-variable 'replace-re-search-function)
+ (kill-local-variable 'require-final-newline)
+ (kill-local-variable 'buffer-substring-filters)
+ (kill-local-variable 'use-hard-newlines)))
+
+(defun longlines-mode-off ()
+ "Turn off longlines mode.
+This function exists to be called by `change-major-mode-hook' when the
+major mode changes."
+ (longlines-mode 0))
+
+;;; Showing the effect of hard newlines in the buffer
+
+(defun longlines-show-hard-newlines (&optional arg)
+ "Make hard newlines visible by adding a face.
+With optional argument ARG, make the hard newlines invisible again."
+ (interactive "P")
+ (if arg
+ (longlines-unshow-hard-newlines)
+ (setq longlines-showing t)
+ (longlines-show-region (point-min) (point-max))))
+
+(defun longlines-show-region (beg end)
+ "Make hard newlines between BEG and END visible."
+ (let* ((pmin (min beg end))
+ (pmax (max beg end))
+ (pos (text-property-not-all pmin pmax 'hard nil))
+ (mod (buffer-modified-p))
+ (buffer-undo-list t)
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t)
+ buffer-file-name buffer-file-truename)
+ (while pos
+ (put-text-property pos (1+ pos) 'display
+ (copy-sequence longlines-show-effect))
+ (setq pos (text-property-not-all (1+ pos) pmax 'hard nil)))
+ (restore-buffer-modified-p mod)))
+
+(defun longlines-unshow-hard-newlines ()
+ "Make hard newlines invisible again."
+ (interactive)
+ (setq longlines-showing nil)
+ (let ((pos (text-property-not-all (point-min) (point-max) 'hard nil))
+ (mod (buffer-modified-p))
+ (buffer-undo-list t)
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t)
+ buffer-file-name buffer-file-truename)
+ (while pos
+ (remove-text-properties pos (1+ pos) '(display nil))
+ (setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
+ (restore-buffer-modified-p mod)))
+
+;;; Wrapping the paragraphs
+
+(defun longlines-wrap-region (beg end)
+ "Wrap each successive line, starting with the line before BEG.
+Stop when we reach lines after END that don't need wrapping, or the
+end of the buffer."
+ (let ((mod (buffer-modified-p)))
+ (setq longlines-wrap-point (point))
+ (goto-char beg)
+ (forward-line -1)
+ ;; Two successful longlines-wrap-line's in a row mean successive
+ ;; lines don't need wrapping.
+ (while (null (and (longlines-wrap-line)
+ (or (eobp)
+ (and (>= (point) end)
+ (longlines-wrap-line))))))
+ (goto-char longlines-wrap-point)
+ (set-buffer-modified-p mod)))
+
+(defun longlines-wrap-line ()
+ "If the current line needs to be wrapped, wrap it and return nil.
+If wrapping is performed, point remains on the line. If the line does
+not need to be wrapped, move point to the next line and return t."
+ (if (longlines-set-breakpoint fill-column)
+ (progn (insert-before-markers-and-inherit ?\n)
+ nil)
+ (if (longlines-merge-lines-p)
+ (progn (end-of-line)
+ ;; After certain commands (e.g. kill-line), there may be two
+ ;; successive soft newlines in the buffer. In this case, we
+ ;; replace these two newlines by a single space. Unfortunately,
+ ;; this breaks the conservation of (spaces + newlines), so we
+ ;; have to fiddle with longlines-wrap-point.
+ (if (or (prog1 (bolp) (forward-char 1)) (eolp))
+ (progn
+ (delete-char -1)
+ (if (> longlines-wrap-point (point))
+ (setq longlines-wrap-point
+ (1- longlines-wrap-point))))
+ (delete-char -1))
+ nil)
+ (forward-line 1)
+ t)))
+
+(defun longlines-set-breakpoint (target-column)
+ "Place point where we should break the current line, and return t.
+If the line should not be broken, return nil; point remains on the
+line."
+ (move-to-column target-column)
+ (let ((non-breakpoint-re (format "[^%s]" longlines-breakpoint-chars)))
+ (if (and (re-search-forward non-breakpoint-re (line-end-position) t 1)
+ (> (current-column) target-column))
+ ;; This line is too long. Can we break it?
+ (or (longlines-find-break-backward)
+ (progn (move-to-column target-column)
+ (longlines-find-break-forward))))))
+
+(defun longlines-find-break-backward ()
+ "Move point backward to the first available breakpoint and return t.
+If no breakpoint is found, return nil."
+ (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars)))
+ (when (and (re-search-backward breakpoint-re (line-beginning-position) t 1)
+ (save-excursion
+ (skip-chars-backward longlines-breakpoint-chars
+ (line-beginning-position))
+ (null (bolp))))
+ (forward-char 1)
+ (if (and fill-nobreak-predicate
+ (run-hook-with-args-until-success 'fill-nobreak-predicate))
+ (progn
+ (skip-chars-backward longlines-breakpoint-chars
+ (line-beginning-position))
+ (longlines-find-break-backward))
+ t))))
+
+(defun longlines-find-break-forward ()
+ "Move point forward to the first available breakpoint and return t.
+If no break point is found, return nil."
+ (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars)))
+ (and (re-search-forward breakpoint-re (line-end-position) t 1)
+ (progn
+ (skip-chars-forward longlines-breakpoint-chars (line-end-position))
+ (null (eolp)))
+ (if (and fill-nobreak-predicate
+ (run-hook-with-args-until-success 'fill-nobreak-predicate))
+ (longlines-find-break-forward)
+ t))))
+
+(defun longlines-merge-lines-p ()
+ "Return t if part of the next line can fit onto the current line.
+Otherwise, return nil. Text cannot be moved across hard newlines."
+ (save-excursion
+ (end-of-line)
+ (and (null (eobp))
+ (null (get-text-property (point) 'hard))
+ (let ((space (- fill-column (current-column))))
+ (forward-line 1)
+ (longlines-set-breakpoint (max 0 (1- space)))))))
+
+(defun longlines-decode-region (&optional beg end)
+ "Turn all newlines between BEG and END into hard newlines.
+If BEG and END are nil, the point and mark are used."
+ (if (null beg) (setq beg (point)))
+ (if (null end) (setq end (mark t)))
+ (save-excursion
+ (let ((reg-max (max beg end)))
+ (goto-char (min beg end))
+ (while (search-forward "\n" reg-max t)
+ (set-hard-newline-properties
+ (match-beginning 0) (match-end 0))))))
+
+(defun longlines-decode-buffer ()
+ "Turn all newlines in the buffer into hard newlines."
+ (longlines-decode-region (point-min) (point-max)))
+
+(defun longlines-encode-region (beg end &optional _buffer)
+ "Remove each soft newline between BEG and END.
+Hard newlines are left intact. The optional argument BUFFER exists for
+compatibility with `format-alist', and is ignored."
+ (save-excursion
+ (let ((reg-max (max beg end))
+ (mod (buffer-modified-p)))
+ (goto-char (min beg end))
+ (while (search-forward "\n" reg-max t)
+ (let ((pos (match-beginning 0)))
+ (unless (get-text-property pos 'hard)
+ (remove-text-properties pos (1+ pos) '(hard nil))
+ (delete-region pos (1+ pos)))))
+ (set-buffer-modified-p mod)
+ end)))
+
+(defun longlines-encode-string (string)
+ "Return a copy of STRING with each soft newline replaced by a space.
+Hard newlines are left intact."
+ (let* ((str (copy-sequence string))
+ (pos (string-search "\n" str)))
+ (while pos
+ (if (null (get-text-property pos 'hard str))
+ (aset str pos ? ))
+ (setq pos (string-search "\n" str (1+ pos))))
+ str))
+
+;;; Auto wrap
+
+(defun longlines-auto-wrap (&optional arg)
+ "Toggle automatic line wrapping.
+With optional argument ARG, turn on line wrapping if and only if
+ARG is positive.
+If automatic line wrapping is turned on, wrap the entire buffer."
+ (interactive "P")
+ (setq arg (if arg
+ (> (prefix-numeric-value arg) 0)
+ (not longlines-auto-wrap)))
+ (if arg
+ (progn
+ (setq longlines-auto-wrap t)
+ (longlines-wrap-region (point-min) (point-max))
+ (message "Auto wrap enabled."))
+ (setq longlines-auto-wrap nil)
+ (message "Auto wrap disabled.")))
+
+(defun longlines-after-change-function (beg end _len)
+ "Update `longlines-wrap-beg' and `longlines-wrap-end'.
+This is called by `after-change-functions' to keep track of the region
+that has changed."
+ (when (and longlines-auto-wrap (not undo-in-progress))
+ (setq longlines-wrap-beg
+ (if longlines-wrap-beg (min longlines-wrap-beg beg) beg))
+ (setq longlines-wrap-end
+ (if longlines-wrap-end (max longlines-wrap-end end) end))))
+
+(defun longlines-post-command-function ()
+ "Perform line wrapping on the parts of the buffer that have changed.
+This is called by `post-command-hook' after each command."
+ (when (and longlines-auto-wrap longlines-wrap-beg)
+ (if (or (eq this-command 'yank)
+ (eq this-command 'yank-pop))
+ (longlines-decode-region (point) (mark t)))
+ (if longlines-showing
+ (longlines-show-region longlines-wrap-beg longlines-wrap-end))
+ (unless (or (eq this-command 'fill-paragraph)
+ (eq this-command 'fill-region))
+ (longlines-wrap-region longlines-wrap-beg longlines-wrap-end))
+ (setq longlines-wrap-beg nil)
+ (setq longlines-wrap-end nil)))
+
+(defun longlines-window-change-function ()
+ "Re-wrap the buffer if the window width has changed.
+This is called by `window-configuration-change-hook'."
+ (let ((dw (if (and (integerp longlines-wrap-follows-window-size)
+ (>= longlines-wrap-follows-window-size 0)
+ (< longlines-wrap-follows-window-size (window-width)))
+ longlines-wrap-follows-window-size
+ 2)))
+ (when (/= fill-column (- (window-width) dw))
+ (setq fill-column (- (window-width) dw))
+ (longlines-wrap-region (point-min) (point-max)))))
+
+;;; Isearch
+
+(defun longlines-search-function ()
+ (cond
+ ((or isearch-regexp-function isearch-regexp) (isearch-search-fun-default))
+ (isearch-forward #'longlines-search-forward)
+ (t #'longlines-search-backward)))
+
+(defun longlines-search-forward (string &optional bound noerror count)
+ (let ((search-spaces-regexp " *[ \n]"))
+ (re-search-forward (regexp-quote string) bound noerror count)))
+
+(defun longlines-search-backward (string &optional bound noerror count)
+ (let ((search-spaces-regexp " *[ \n]"))
+ (re-search-backward (regexp-quote string) bound noerror count)))
+
+(defun longlines-re-search-forward (string &optional bound noerror count)
+ (let ((search-spaces-regexp " *[ \n]"))
+ (re-search-forward string bound noerror count)))
+
+;;; Loading and saving
+
+(defun longlines-before-revert-hook ()
+ (add-hook 'after-revert-hook #'longlines-after-revert-hook nil t)
+ (longlines-mode 0))
+
+(defun longlines-after-revert-hook ()
+ (remove-hook 'after-revert-hook #'longlines-after-revert-hook t)
+ (longlines-mode 1))
+
+(add-to-list
+ 'format-alist
+ (list 'longlines "Automatically wrap long lines." nil nil
+ #'longlines-encode-region t nil))
+
+;;; Unloading
+
+(defun longlines-unload-function ()
+ "Unload the longlines library."
+ (save-current-buffer
+ (dolist (buffer (buffer-list))
+ (set-buffer buffer)
+ (longlines-mode-off)))
+ ;; continue standard unloading
+ nil)
+
+(provide 'longlines)
+
+;;; longlines.el ends here
XSETFASTINT (BVAR (&buffer_local_flags, tab_line_format), idx); ++idx;
XSETFASTINT (BVAR (&buffer_local_flags, cursor_type), idx); ++idx;
XSETFASTINT (BVAR (&buffer_local_flags, extra_line_spacing), idx); ++idx;
+ XSETFASTINT (BVAR (&buffer_local_flags, auto_narrow__narrowing_state), idx);
+ /* Make this one a permanent local. */
+ buffer_permanent_local_flags[idx++] = 1;
XSETFASTINT (BVAR (&buffer_local_flags, cursor_in_non_selected_windows), idx); ++idx;
/* buffer_local_flags contains no pointers, so it's safe to treat it
%p -- print percent of buffer above top of window, or Top, Bot or All.
%P -- print percent of buffer above bottom of window, perhaps plus Top,
or print Bottom or All.
- %n -- print Narrow if appropriate.
+ %n -- print Narrow or Auto-Narrow if appropriate.
%t -- visited file is text or binary (if OS supports this distinction).
%z -- print mnemonics of keyboard, terminal, and buffer coding systems.
%Z -- like %z, but including the end-of-line format.
If value is a floating point number, it specifies the spacing relative
to the default frame line height. A value of nil means add no extra space. */);
+ DEFVAR_PER_BUFFER ("auto-narrow--narrowing-state",
+ &BVAR (current_buffer, auto_narrow__narrowing_state), Qnil,
+ doc: /* Internal variable used by `auto-narrow-mode'. */);
+
DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
&BVAR (current_buffer, cursor_in_non_selected_windows), Qnil,
doc: /* Non-nil means show a cursor in non-selected windows.
in the display of this buffer. */
Lisp_Object extra_line_spacing_;
+ /* Narrowing state when auto-narrow mode is in effect. */
+ Lisp_Object auto_narrow__narrowing_state_;
+
/* Cursor type to display in non-selected windows.
t means to use hollow box cursor.
See `cursor-type' for other values. */
{
b->width_table_ = val;
}
+INLINE void
+bset_auto_narrow__narrowing_state (struct buffer *b, Lisp_Object val)
+{
+ b->auto_narrow__narrowing_state_ = val;
+}
/* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
the max (resp. min) p such that
}
}
+INLINE bool
+BUFFER_AUTO_NARROWED_P (struct buffer *b)
+{
+ return EQ (BVAR (b, auto_narrow__narrowing_state), Qauto);
+}
+
/* This structure holds the default values of the buffer-local variables
that have special slots in each buffer.
The default value occupies the same slot in this structure
Otherwise start with an empty undo_list. */
bset_undo_list (current_buffer, EQ (old_undo, Qt) ? Qt : Qnil);
+ if (!noninteractive
+ && !NILP (Vauto_narrow_long_line_threshold)
+ && !NILP (CALLN
+ (Fgtr,
+ Fcar (Fcdr (Fbuffer_line_statistics (Fcurrent_buffer ()))),
+ Vauto_narrow_long_line_threshold)))
+ {
+ bset_auto_narrow__narrowing_state (current_buffer, Qneeded);
+ }
+
unbind_to (count1, Qnil);
}
/* Lisp function for recursively deleting directories. */
DEFSYM (Qdelete_directory, "delete-directory");
+ DEFVAR_LISP ("auto-narrow-long-line-threshold",
+ Vauto_narrow_long_line_threshold,
+ doc: /* Line length above which `auto-narrow-mode' is entered.
+When non-nil, and when a file with one or more lines longer than
+`auto-narrow-long-line-threshold' is opened or inserted in a buffer,
+`auto-narrow-mode' is automatically enabled.
+When nil, `auto-narrow-mode' is disabled. */);
+ Vauto_narrow_long_line_threshold = Qnil;
+
+ DEFSYM (Qauto_narrow_mode, "auto-narrow-mode");
+
DEFSYM (Qsubstitute_env_in_file_name, "substitute-env-in-file-name");
DEFSYM (Qget_buffer_window_list, "get-buffer-window-list");
if (NILP (Vmemory_full))
{
+ if (!NILP (Vauto_narrow_post_command_function) && !NILP (Vrun_hooks))
+ safe_run_hooks (Qauto_narrow_post_command_function);
+
/* Make sure this hook runs after commands that get errors and
throw to top level. */
/* Note that the value cell will never directly contain nil
Vreal_this_command = cmd;
safe_run_hooks (Qpre_command_hook);
+ safe_run_hooks (Qauto_narrow_pre_command_function);
+
already_adjusted = 0;
if (NILP (Vthis_command))
}
kset_last_prefix_arg (current_kboard, Vcurrent_prefix_arg);
+ safe_run_hooks (Qauto_narrow_post_command_function);
+
safe_run_hooks (Qpost_command_hook);
/* If displaying a message, resize the echo area window to fit
DEFSYM (Qpre_command_hook, "pre-command-hook");
DEFSYM (Qpost_command_hook, "post-command-hook");
+ DEFSYM (Qauto_narrow_pre_command_function,
+ "auto-narrow-pre-command-function");
+ DEFSYM (Qauto_narrow_post_command_function,
+ "auto-narrow-post-command-function");
+
DEFSYM (Qundo_auto__add_boundary, "undo-auto--add-boundary");
DEFSYM (Qundo_auto__undoably_changed_buffers,
"undo-auto--undoably-changed-buffers");
See also `pre-command-hook'. */);
Vpost_command_hook = Qnil;
+ DEFVAR_LISP ("auto-narrow-pre-command-function",
+ Vauto_narrow_pre_command_function,
+ doc: /* Function executed before each command is executed in `auto-narrow-mode'.
+If non-nil, and `auto-narrow-mode' is enabled, the function is
+called before each command is executed, after `pre-command-hook'.
+It is called without arguments. */);
+ Vauto_narrow_pre_command_function = Qnil;
+
+ DEFVAR_LISP ("auto-narrow-post-command-function",
+ Vauto_narrow_post_command_function,
+ doc: /* Function executed after each command is executed in `auto-narrow-mode'.
+If non-nil, and `auto-narrow-mode' is enabled, the function is
+called after each command is executed, before `post-command-hook'.
+It is called without arguments. */);
+ Vauto_narrow_post_command_function = Qnil;
+
#if 0
DEFVAR_LISP ("echo-area-clear-hook", ...,
doc: /* Normal hook run when clearing the echo area. */);
&& NILP (echo_area_buffer[0])))
{
struct buffer *buf = XBUFFER (w->contents);
- whole = BUF_ZV (buf) - BUF_BEGV (buf);
- start = marker_position (w->start) - BUF_BEGV (buf);
- /* I don't think this is guaranteed to be right. For the
- moment, we'll pretend it is. */
- end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
+ if (! BUFFER_AUTO_NARROWED_P (current_buffer))
+ {
+ whole = BUF_ZV (buf) - BUF_BEGV (buf);
+ start = marker_position (w->start) - BUF_BEGV (buf);
+ /* I don't think this is guaranteed to be right. For the
+ moment, we'll pretend it is. */
+ end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
+ }
+ else
+ {
+ whole = BUF_Z (buf) - BUF_BEG (buf);
+ start = marker_position (w->start) - BUF_BEG (buf);
+ end = BUF_Z (buf) - w->window_end_pos - BUF_BEG (buf);
+ }
if (end < start)
end = start;
variables. */
set_buffer_internal_1 (XBUFFER (w->contents));
+ if (EQ (BVAR (current_buffer, auto_narrow__narrowing_state), Qneeded))
+ {
+ safe_call (1, Qauto_narrow_mode);
+ /* Normally set by auto-narrow-mode, set it here anyway as a safety measure. */
+ bset_auto_narrow__narrowing_state (current_buffer, Qauto);
+ message1 ("Auto-Narrow mode enabled in current buffer");
+ }
+
current_matrix_up_to_date_p
= (w->window_end_valid
&& !current_buffer->clip_changed
case 'n':
if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
- return " Narrow";
+ {
+ if (! BUFFER_AUTO_NARROWED_P (b))
+ return " Narrow";
+ else
+ return " Auto-Narrow";
+ }
break;
/* Display the "degree of travel" of the window through the buffer. */
{
ptrdiff_t toppos = marker_position (w->start);
ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
- ptrdiff_t begv = BUF_BEGV (b);
- ptrdiff_t zv = BUF_ZV (b);
+ ptrdiff_t beg, z;
- if (zv <= botpos)
- return toppos <= begv ? "All" : "Bottom";
- else if (toppos <= begv)
+ if (! BUFFER_AUTO_NARROWED_P (b))
+ {
+ beg = BUF_BEGV (b);
+ z = BUF_ZV (b);
+ }
+ else
+ {
+ beg = BUF_BEG (b);
+ z = BUF_Z (b);
+ }
+
+ if (z <= botpos)
+ return toppos <= beg ? "All" : "Bottom";
+ else if (toppos <= beg)
return "Top";
else
{
sprintf (decode_mode_spec_buf, "%2d%%",
- percent99 (toppos - begv, (toppos - begv) + (zv - botpos)));
+ percent99 (toppos - beg, (toppos - beg) + (z - botpos)));
return decode_mode_spec_buf;
}
}
case 'p':
{
ptrdiff_t pos = marker_position (w->start);
- ptrdiff_t begv = BUF_BEGV (b);
- ptrdiff_t zv = BUF_ZV (b);
+ ptrdiff_t beg, z;
- if (w->window_end_pos <= BUF_Z (b) - zv)
- return pos <= begv ? "All" : "Bottom";
- else if (pos <= begv)
+ if (! BUFFER_AUTO_NARROWED_P (b))
+ {
+ beg = BUF_BEGV (b);
+ z = BUF_ZV (b);
+ }
+ else
+ {
+ beg = BUF_BEG (b);
+ z = BUF_Z (b);
+ }
+
+ if (w->window_end_pos <= BUF_Z (b) - z)
+ return pos <= beg ? "All" : "Bottom";
+ else if (pos <= beg)
return "Top";
else
{
sprintf (decode_mode_spec_buf, "%2d%%",
- percent99 (pos - begv, zv - begv));
+ percent99 (pos - beg, z - beg));
return decode_mode_spec_buf;
}
}
{
ptrdiff_t toppos = marker_position (w->start);
ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
- ptrdiff_t begv = BUF_BEGV (b);
- ptrdiff_t zv = BUF_ZV (b);
+ ptrdiff_t beg, z;
- if (zv <= botpos)
- return toppos <= begv ? "All" : "Bottom";
+ if (! BUFFER_AUTO_NARROWED_P (b))
+ {
+ beg = BUF_BEGV (b);
+ z = BUF_ZV (b);
+ }
+ else
+ {
+ beg = BUF_BEG (b);
+ z = BUF_Z (b);
+ }
+
+ if (z <= botpos)
+ return toppos <= beg ? "All" : "Bottom";
else
{
sprintf (decode_mode_spec_buf,
- &"Top%2d%%"[begv < toppos ? sizeof "Top" - 1 : 0],
- percent99 (botpos - begv, zv - begv));
+ &"Top%2d%%"[beg < toppos ? sizeof "Top" - 1 : 0],
+ percent99 (botpos - beg, z - beg));
return decode_mode_spec_buf;
}
}
{
ptrdiff_t toppos = marker_position (w->start);
ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
- ptrdiff_t begv = BUF_BEGV (b);
- ptrdiff_t zv = BUF_ZV (b);
+ ptrdiff_t beg, z;
int top_perc, bot_perc;
- if ((toppos <= begv) && (zv <= botpos))
+ if (! BUFFER_AUTO_NARROWED_P (b))
+ {
+ beg = BUF_BEGV (b);
+ z = BUF_ZV (b);
+ }
+ else
+ {
+ beg = BUF_BEG (b);
+ z = BUF_Z (b);
+ }
+
+ if ((toppos <= beg) && (z <= botpos))
return "All ";
- top_perc = toppos <= begv ? 0 : percent99 (toppos - begv, zv - begv);
- bot_perc = zv <= botpos ? 100 : percent99 (botpos - begv, zv - begv);
+ top_perc = toppos <= beg ? 0 : percent99 (toppos - beg, z - beg);
+ bot_perc = z <= botpos ? 100 : percent99 (botpos - beg, z - beg);
if (top_perc == bot_perc)
sprintf (decode_mode_spec_buf, "%d%%", top_perc);
DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
DEFSYM (Qeval, "eval");
DEFSYM (QCdata, ":data");
+ DEFSYM (Qneeded, "needed");
+ DEFSYM (Qauto, "auto");
/* Names of text properties relevant for redisplay. */
DEFSYM (Qdisplay, "display");
projects / emacs.git / commitdiff