longlines.el 2.1 -- automatically wrap long lines

[Chong Yidong]

This fixes some bugs in killing and yanking. It should work properly
now.


;;; longlines.el --- automatically wrap long lines -*- coding: iso-8859-1; -*-

;; Copyright (C) 2000, 2001 by Free Software Foundation, Inc.
;; Copyright (C) 2004 by Chong Yidong.

;; Authors:    Kai Grossjohann <address@hidden>
;;             Alex Schroeder <address@hidden>
;;             Chong Yidong <address@hidden>
;; Maintainer: Chong Yidong <address@hidden>
;; Version: 2.1
;; Keywords: convenience

;; This file 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 2, or (at your option)
;; any later version.

;; This file 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; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; 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. This file 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.

;;; Code:

(require 'easy-mmode)
(when (not (fboundp 'overlays-in)) (require 'overlay)) ;; for XEmacs

;; Customization

(defgroup longlines nil
  "Automatic wrapping of long lines when loading files."
  :group 'fill)

(defcustom longlines-auto-wrap t
  "*If non-nil, longlines-mode ensures that long lines are
automatically wrapped after each command."
  :group 'longlines
  :type 'boolean)

(defcustom longlines-wrap-follows-window-size nil
  "*If non-nil, wrapping and filling happen at the edge of the window.
Otherwise, `fill-column' is used, regardless of the window size. This
is experimental! I haven't figured out how to handle the case where
the buffer is displayed in multiple windows with different sizes."
  :group 'wrap
  :type 'boolean)

(defcustom longlines-show-hard-newlines nil
  "*If non-nil, the location of every hard newline in the buffer will
be indicated with a symbol."
  :group 'longlines
  :type 'boolean)

(defcustom longlines-show-effect '(before-string . "¶")
  "Determines how hard newlines are made visible."
  :group 'longlines
  :type '(choice
          (const :tag "Pi" (before-string . "¶"))
          (const :tag "Default Face" (face . longlines-visible-face))
          (cons :tag "Custom Face"
                :value (face . longlines-visible-face)
                (const :tag "Property" face) face)
          (cons :tag "Property" 
                :value (face . longlines-visible-face)
                (symbol :tag "Property") (sexp :tag "Value"))))

;; Internal variables

(defvar longlines-wrap-beg nil)
(defvar longlines-wrap-end nil)
(defvar longlines-wrap-point nil)
(defvar longlines-showing 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)

;; Showing the effect of hard newlines in the buffer

(defface longlines-visible-face
  '((t (:background "red")))
  "Face used to make hard newlines visible in `longlines-mode'.")

(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
by calling `longlines-unshow-hard-newlines'."
  (interactive "P")
  (if arg
      (longlines-unshow-hard-newlines)
    (save-excursion
      (setq longlines-showing t)
      ;; We want to show every single newline.  Therefore every single
      ;; newline must get its own overlay.  No spanning of multiple
      ;; newlines with one overlay.
      (let ((pos (text-property-any (point-min) (point-max) 'hard t)))
        (while pos
          (longlines-show-region pos (1+ pos))
          (setq pos (text-property-any (1+ pos) (point-max) 'hard t)))))))

(defun longlines-show-region (start end)
  "Make region between START and END visible."
  (unless (let ((os (overlays-in start end))
                o exists)
            (while (and os (not exists))
              (setq o (car os)
                    os (cdr os))
              (when (overlay-get o 'longlines)
                (setq exists t)))
            exists)
    (let ((o (make-overlay start end nil t)))
      (overlay-put o (car longlines-show-effect) (cdr longlines-show-effect))
      (overlay-put o 'longlines t)
      (overlay-put o 'evaporate t))))

(defun longlines-unshow-hard-newlines ()
  "Make hard newlines invisible again."
  (interactive)
  (setq longlines-showing nil)
  (let ((os (overlays-in (point-min) (point-max)))
        o)
    (while os
      (setq o (car os)
            os (cdr os))
      (when (overlay-get o 'longlines)
        (delete-overlay o)))))

;; Wrapping the paragraphs.

(defun longlines-wrap-region (start end)
  "Wrap each successive line, starting with the line before START.
Stop when we reach lines after END that don't need wrapping, or the
end of the buffer."
  (setq longlines-wrap-point (point))
  (goto-char start)
  (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))

(defun longlines-wrap-line ()
  "Wrap this line if necessary. If wrapping is performed, point
remains on the line. Otherwise, point advances to the next line.
Return t if the current line did not require adjusting, and nil
otherwise."
  (if (longlines-set-breakpoint)
      (progn (backward-delete-char 1)
             (insert-char ?\n 1)
             nil)
    (if (longlines-merge-lines-p)
        (progn (end-of-line)
               (delete-char 1)
     ;; This handles behavior induced by, e.g., kill-line.
     ;; Unfortunately, it breaks conservation of (spaces + newlines),
     ;; so we have to fiddle with longlines-wrap-point.
               (if (or (bolp) (eolp))
                   (if (> longlines-wrap-point (point))
                       (setq longlines-wrap-point
                             (1- longlines-wrap-point)))
                 (insert-char ?  1))
               nil)
      (forward-line 1)
      t)))

(defun longlines-set-breakpoint ()
  "Place point where we should break this line, and return t. If this
line should not be broken, return nil; point remains on the line."
  (move-to-column fill-column)
  (if (and (re-search-forward "[^ ]" (line-end-position) 1)
           (> (current-column) fill-column))
      ;; This line is too long. Can we break it?
      (or (longlines-find-break-backward)
          (progn (move-to-column fill-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."
  (and (search-backward " " (line-beginning-position) 1)
       (save-excursion
         (skip-chars-backward " " (line-beginning-position))
         (null (bolp)))
       (progn (forward-char 1)
              (if (and fill-nobreak-predicate
                       (funcall fill-nobreak-predicate))
                  (progn (skip-chars-backward " " (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."
  (and (search-forward " " (line-end-position) 1)
       (progn (skip-chars-forward " " (line-end-position))
              (null (eolp)))
       (if (and fill-nobreak-predicate
                (funcall fill-nobreak-predicate))
           (longlines-find-break-forward)
         t)))

(defun longlines-merge-lines-p ()
  "If some of the text on the next line can be fitted onto the current
line, return t. 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)
           (if (eq (char-after) ? )
               t ;; We can always merge some spaces
             (<= (if (search-forward " " (line-end-position) 1)
                     (current-column)
                   (1+ (current-column)))
                 space))))))

(defun longlines-decode-region (beg end)
  "Turn all newlines between START and END into hard newlines."
  (use-hard-newlines 1 'never)
  (save-excursion
    (let ((reg-min (min beg end))
          (reg-max (max beg end)))
      (goto-char reg-min)
      (while (search-forward "\n" reg-max t)
        (set-hard-newline-properties (match-beginning 0) (match-end 0))))))

(defun longlines-encode-region (beg end &optional buffer)
  "Replace each soft newline between START and END with exactly one
space. Hard newlines are left intact. The optional argument BUFFER
is ignored; it is there for compatibility with `format-alist'."
  (save-excursion
    (let ((reg-min (min beg end))
          (reg-max (max beg end)))
      (goto-char reg-min)
      (while (search-forward "\n" reg-max t)
        (unless (get-text-property (match-beginning 0) 'hard)
          (replace-match " ")))
      end)))

;; Auto wrap

(defun longlines-auto-wrap (&optional arg)
  "Turn on automatic wrapping of lines, and wrap the entire buffer.
With optional argument ARG, turn off line wrapping."
  (interactive "P")
  (remove-hook 'after-change-functions 'longlines-after-change-function t)
  (remove-hook 'post-command-hook 'longlines-post-command-function t)
  (if arg
      (progn (setq longlines-auto-wrap nil)
             (message "Auto wrap disabled."))
    (setq longlines-auto-wrap t)
    (add-hook 'after-change-functions
              'longlines-after-change-function nil t)
    (add-hook 'post-command-hook
              'longlines-post-command-function nil t)
    (longlines-wrap-region (point-min) (point-max))
    (message "Auto wrap enabled.")))

(defun longlines-after-change-function (beg end len)
  "Set `longlines-wrap-beg' and `longlines-wrap-end' to indicate the
changed region. Called by `after-change-functions'."
  (unless 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 ()
  "Function called by `post-command-hook' to perform line wrapping
after each command."
  (when longlines-wrap-beg ; there was a change
    (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. Called by
`window-size-change-functions'."
  (when (/= fill-column (- (window-width) window-min-width))
    (setq fill-column (- (window-width) window-min-width))
    (let ((mod (buffer-modified-p)))
      (longlines-wrap-region (point-min) (point-max))
      (set-buffer-modified-p mod))))

;; Advice for editing functions

(defadvice newline (after newline-shows-hard-ones activate)
  "When a hard newline is inserted, it will also be highlighted.
This happens only if `longlines-showing' is non-nil."
  (save-excursion
    (when (and longlines-showing
               (search-backward "\n" nil t))
      (longlines-show-region (match-beginning 0) (match-end 0)))))

(defadvice kill-region (before longlines-encode-kill activate)
  "If the buffer is in `longlines-mode', pass the region through
`longlines-encode-region' to strip out soft newlines."
  (when longlines-mode
    (longlines-encode-region beg end)))

(defadvice copy-region-as-kill (around longlines-encode-kill activate)
  "If the buffer is in `longlines-mode', pass the region through
`longlines-encode-region' to strip out soft newlines."
  (if longlines-mode
      (let ((string (buffer-substring beg end)))
        (with-temp-buffer
          (insert string)
          (longlines-encode-region (point-min) (point-max))
          (setq beg (point-min))
          (setq end (point-max))
          ad-do-it))
    ad-do-it))

(defadvice yank (after longlines-decode-kill activate)
  "If the buffer is in `longlines-mode', pass the returned kill
through `longlines-decode-region' to mark newlines as hard."
  (when longlines-mode
    (longlines-decode-region (point) (mark t))
    (if longlines-showing
        (longlines-show-hard-newlines))))

(defadvice yank-pop (after longlines-decode-kill activate)
  "If the buffer is in `longlines-mode', pass the returned kill
through `longlines-decode-region' to mark newlines as hard."
  (when longlines-mode
    (longlines-decode-region (point) (mark t))
    (if longlines-showing
        (longlines-show-hard-newlines))))

;; Loading and saving

(add-to-list 'format-alist
             (list 'longlines               ;name
                   "Automatically wrap long lines." ;doc
                   nil                      ;regexp
                   'longlines-decode-region ;decode
                   'longlines-encode-region ;encode
                   t                        ;modify
                   nil))                    ;mode function

;; Mode

(define-minor-mode longlines-mode
  "Toggle Long Lines mode.
In Long Lines mode, long lines will be wrapped if they extend beyond
`fill-column'. The newlines used for line wrapping will not show up
when the file is saved or the text is yanked.

If `longlines-auto-wrap' is non-nil, line wrapping occurs
automatically every time the buffer is changed. You can also call
`fill-paragraph' to fill individual paragraphs.

If `longlines-show-hard-newlines' is non-nil, hard newlines will be
marked by a symbol."
  nil " ll" nil
  (if longlines-mode
      ;; Turn on longlines mode
      (progn
        (add-to-list 'buffer-file-format 'longlines)
        (when longlines-auto-wrap
          (auto-fill-mode 0)
          (add-hook 'after-change-functions
                    'longlines-after-change-function nil t)
          (add-hook 'post-command-hook
                    'longlines-post-command-function nil t))
        (when longlines-wrap-follows-window-size
          (set (make-local-variable 'fill-column)
               (- (window-width) window-min-width))
          (add-hook 'window-configuration-change-hook
                    'longlines-window-change-function nil t))
        (let ((mod (buffer-modified-p)))
          (longlines-decode-region (point-min) (point-max))
          (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)))
    ;; Turn off longlines mode
    (setq buffer-file-format (delete 'longlines buffer-file-format))
    (longlines-unshow-hard-newlines)
    (let ((mod (buffer-modified-p)))
      (longlines-encode-region (point-min) (point-max))
      (set-buffer-modified-p mod))
    (remove-hook 'after-change-functions 'longlines-after-change-function t)
    (remove-hook 'post-command-hook 'longlines-post-command-function t)
    (remove-hook 'window-configuration-change-hook
                 'longlines-window-change-function t)
    (kill-local-variable 'fill-column)))

(provide 'longlines)

;;; longlines.el ends here