* longlines and global-auto-revert-mode
@ 2008-01-15 10:01 Dmitry Bolshakov
0 siblings, 0 replies; 5+ messages in thread
From: Dmitry Bolshakov @ 2008-01-15 10:01 UTC (permalink / raw)
To: help-gnu-emacs
Hi All.
My system:
WinXP
GNU Emacs 22.1.1 (i386-mingw-nt5.1.2600) of 2007-06-02 on RELEASE
In order to be informed that file has been modified externally, I have
added this in my .emacs:
(global-auto-revert-mode 1)
(defun inform-revert-modified-file (&optional p1 p2)
(let ((revert-buffer-function nil))
(revert-buffer p1 p2)
(message-box "emacs: modified file automatically reverted: %s"
(buffer-file-name))
)
)
(setq revert-buffer-function 'inform-revert-modified-file)
It works fine, but if longlines-mode is active, then when file is been
modified by external program, I get not only my message, but before it I
get question in minibuffer "filename.txt changed on disk; really edit
the buffer? (y, n, r or C-h)". Why? I want only my message. How to
disable this question?
--
With best regards
Dmitry Bolshakov
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: longlines and global-auto-revert-mode
@ 2008-01-15 17:35 martin rudalics
2008-01-16 10:07 ` Dmitry Bolshakov
0 siblings, 1 reply; 5+ messages in thread
From: martin rudalics @ 2008-01-15 17:35 UTC (permalink / raw)
To: dmitry.bolshakov; +Cc: help-gnu-emacs
[-- Attachment #1: Type: text/plain, Size: 436 bytes --]
> It works fine, but if longlines-mode is active, then when file is been
> modified by external program, I get not only my message, but before it I
> get question in minibuffer "filename.txt changed on disk; really edit
> the buffer? (y, n, r or C-h)". Why? I want only my message. How to
> disable this question?
Can you try the attached patch? It's against CVS Emacs hence
if you have any problems applying it please tell me.
[-- Attachment #2: longlines.patch --]
[-- Type: text/plain, Size: 2573 bytes --]
*** longlines.el.~1.41.~ Fri Nov 30 10:00:46 2007
--- longlines.el Tue Jan 15 18:29:16 2008
***************
*** 136,142 ****
(let ((buffer-undo-list t)
(inhibit-read-only t)
(after-change-functions nil)
! (mod (buffer-modified-p)))
;; 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
--- 136,143 ----
(let ((buffer-undo-list t)
(inhibit-read-only t)
(after-change-functions nil)
! (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
***************
*** 176,182 ****
(longlines-unshow-hard-newlines))
(let ((buffer-undo-list t)
(after-change-functions nil)
! (inhibit-read-only t))
(if longlines-decoded
(save-restriction
(widen)
--- 177,184 ----
(longlines-unshow-hard-newlines))
(let ((buffer-undo-list t)
(after-change-functions nil)
! (inhibit-read-only t)
! buffer-file-name buffer-file-truename)
(if longlines-decoded
(save-restriction
(widen)
***************
*** 220,226 ****
(mod (buffer-modified-p))
(buffer-undo-list t)
(inhibit-read-only t)
! (inhibit-modification-hooks t))
(while pos
(put-text-property pos (1+ pos) 'display
(copy-sequence longlines-show-effect))
--- 222,229 ----
(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))
***************
*** 235,241 ****
(mod (buffer-modified-p))
(buffer-undo-list t)
(inhibit-read-only t)
! (inhibit-modification-hooks t))
(while pos
(remove-text-properties pos (1+ pos) '(display))
(setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
--- 238,245 ----
(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))
(setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
[-- Attachment #3: Type: text/plain, Size: 152 bytes --]
_______________________________________________
help-gnu-emacs mailing list
help-gnu-emacs@gnu.org
http://lists.gnu.org/mailman/listinfo/help-gnu-emacs
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: longlines and global-auto-revert-mode
2008-01-15 17:35 martin rudalics
@ 2008-01-16 10:07 ` Dmitry Bolshakov
2008-01-16 10:55 ` martin rudalics
0 siblings, 1 reply; 5+ messages in thread
From: Dmitry Bolshakov @ 2008-01-16 10:07 UTC (permalink / raw)
To: martin rudalics; +Cc: help-gnu-emacs
[-- Attachment #1: Type: text/plain, Size: 1138 bytes --]
> > It works fine, but if longlines-mode is active, then when file is been
> > modified by external program, I get not only my message, but before it I
> > get question in minibuffer "filename.txt changed on disk; really edit
> > the buffer? (y, n, r or C-h)". Why? I want only my message. How to
> > disable this question?
>
> Can you try the attached patch? It's against CVS Emacs hence
> if you have any problems applying it please tell me.
>
I coud not apply patch:
> patch --dry-run <longlines.patch
(Stripping trailing CRs from patch.)
patching file longlines.el
Hunk #1 succeeded at 121 (offset -15 lines).
Hunk #2 FAILED at 162.
Hunk #3 FAILED at 207.
Hunk #4 FAILED at 223.
3 out of 4 hunks FAILED -- saving rejects to file longlines.el.rej
>
>
> patch --dry-run -F 30 <longlines.patch
(Stripping trailing CRs from patch.)
patching file longlines.el
Hunk #1 succeeded at 121 (offset -15 lines).
Hunk #2 succeeded at 162 with fuzz 3 (offset -15 lines).
Hunk #3 FAILED at 207.
Hunk #4 FAILED at 223.
2 out of 4 hunks FAILED -- saving rejects to file longlines.el.rej
>
>
>
--
With best regards
Dmitry Bolshakov
[-- Attachment #2: longlines.patch --]
[-- Type: text/plain, Size: 2573 bytes --]
*** longlines.el.~1.41.~ Fri Nov 30 10:00:46 2007
--- longlines.el Tue Jan 15 18:29:16 2008
***************
*** 136,142 ****
(let ((buffer-undo-list t)
(inhibit-read-only t)
(after-change-functions nil)
! (mod (buffer-modified-p)))
;; 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
--- 136,143 ----
(let ((buffer-undo-list t)
(inhibit-read-only t)
(after-change-functions nil)
! (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
***************
*** 176,182 ****
(longlines-unshow-hard-newlines))
(let ((buffer-undo-list t)
(after-change-functions nil)
! (inhibit-read-only t))
(if longlines-decoded
(save-restriction
(widen)
--- 177,184 ----
(longlines-unshow-hard-newlines))
(let ((buffer-undo-list t)
(after-change-functions nil)
! (inhibit-read-only t)
! buffer-file-name buffer-file-truename)
(if longlines-decoded
(save-restriction
(widen)
***************
*** 220,226 ****
(mod (buffer-modified-p))
(buffer-undo-list t)
(inhibit-read-only t)
! (inhibit-modification-hooks t))
(while pos
(put-text-property pos (1+ pos) 'display
(copy-sequence longlines-show-effect))
--- 222,229 ----
(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))
***************
*** 235,241 ****
(mod (buffer-modified-p))
(buffer-undo-list t)
(inhibit-read-only t)
! (inhibit-modification-hooks t))
(while pos
(remove-text-properties pos (1+ pos) '(display))
(setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
--- 238,245 ----
(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))
(setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))
[-- Attachment #3: longlines.el --]
[-- Type: text/plain, Size: 17833 bytes --]
;;; longlines.el --- automatically wrap long lines
;; Copyright (C) 2000, 2001, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
;; Authors: Kai Grossjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE>
;; Alex Schroeder <alex@gnu.org>
;; Chong Yidong <cyd@stupidchicken.com>
;; Maintainer: Chong Yidong <cyd@stupidchicken.com>
;; 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 2, 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; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, 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. 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:
(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."
:group 'longlines
: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."
:group 'longlines
: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'."
:group 'longlines
: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."
:group 'longlines
:type 'string)
;; 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)
;; Mode
;;;###autoload
(define-minor-mode longlines-mode
"Toggle Long Lines mode.
In Long Lines mode, 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."
:group 'longlines :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)
(set (make-local-variable 'isearch-search-fun-function)
'longlines-search-function)
(add-to-list 'buffer-substring-filters 'longlines-encode-string)
(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 ((buffer-undo-list t)
(inhibit-read-only t)
(after-change-functions nil)
(mod (buffer-modified-p)))
;; 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)
(longlines-decode-buffer)
(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)
(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-to-list 'message-indent-citation-function
'longlines-decode-region t)))
(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)))
;; 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)
(after-change-functions nil)
(inhibit-read-only t))
(save-restriction
(widen)
(longlines-encode-region (point-min) (point-max))))
(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 '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")
(let ((buffer-undo-list t)
(mod (buffer-modified-p)))
(if arg
(longlines-unshow-hard-newlines)
(setq longlines-showing t)
(longlines-show-region (point-min) (point-max)))
(set-buffer-modified-p mod)))
(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))
(inhibit-read-only t))
(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)))))
(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)))
(while pos
(remove-text-properties pos (1+ pos) '(display))
(setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil)))))
;; 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."
(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))
(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)
(progn (insert-before-markers ?\n)
(backward-char 1)
(delete-char -1)
(forward-char 1)
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))))
(insert-before-markers-and-inherit ?\s)
(backward-char 1)
(delete-char -1)
(forward-char 1))
nil)
(forward-line 1)
t)))
(defun longlines-set-breakpoint ()
"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 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
(run-hook-with-args-until-success
'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
(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)
(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 (&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)
"Replace each soft newline between BEG and END with exactly one space.
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)
(unless (get-text-property (match-beginning 0) 'hard)
(replace-match " ")))
(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-match "\n" str)))
(while pos
(if (null (get-text-property pos 'hard str))
(aset str pos ? ))
(setq pos (string-match "\n" str (1+ pos))))
str))
;; Auto wrap
(defun longlines-auto-wrap (&optional arg)
"Turn on automatic line wrapping, 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)
(let ((mod (buffer-modified-p)))
(longlines-wrap-region (point-min) (point-max))
(set-buffer-modified-p mod))
(message "Auto wrap enabled.")))
(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."
(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 ()
"Perform line wrapping on the parts of the buffer that have changed.
This is called by `post-command-hook' after each command."
(when 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'."
(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))))
;; Isearch
(defun longlines-search-function ()
(cond
(isearch-word
(if isearch-forward 'word-search-forward 'word-search-backward))
(isearch-regexp
(if isearch-forward 're-search-forward 're-search-backward))
(t
(if isearch-forward
'longlines-search-forward
'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)))
;; 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))
(provide 'longlines)
;; arch-tag: 3489d225-5506-47b9-8659-d8807b77c624
;;; longlines.el ends here
[-- Attachment #4: Type: text/plain, Size: 152 bytes --]
_______________________________________________
help-gnu-emacs mailing list
help-gnu-emacs@gnu.org
http://lists.gnu.org/mailman/listinfo/help-gnu-emacs
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: longlines and global-auto-revert-mode
2008-01-16 10:07 ` Dmitry Bolshakov
@ 2008-01-16 10:55 ` martin rudalics
2008-01-16 12:29 ` Dmitry Bolshakov
0 siblings, 1 reply; 5+ messages in thread
From: martin rudalics @ 2008-01-16 10:55 UTC (permalink / raw)
To: Dmitry Bolshakov; +Cc: help-gnu-emacs
[-- Attachment #1: Type: text/plain, Size: 832 bytes --]
> I coud not apply patch:
I was afraid it won't. I'll attach my current version of longlines.el,
please try it. If the byte-compiler gets you an error I have to find
the version of this in emacs 22.1 and patch it. But that version has
some other bugs in this context, hence it's maybe not reasonably to use.
If you want to fix that manually: FWIW the bug is caused by the fact
that before reverting the buffer longlines-mode wants to remove its
newlines. At this time your file has already changed on disk, Emacs
notices that and tells you about it. By binding `buffer-file-name' and
`buffer-file-truename' to nil while removing these newlines you should
be able to trick Emacs into believing that the buffer is not associated
with any file and so not ask any questions.
Sorry, it's a never-ending story with this problem.
[-- Attachment #2: longlines.el --]
[-- Type: text/plain, Size: 18757 bytes --]
;;; longlines.el --- automatically wrap long lines
;; Copyright (C) 2000, 2001, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
;; Authors: Kai Grossjohann <Kai.Grossjohann@CS.Uni-Dortmund.DE>
;; Alex Schroeder <alex@gnu.org>
;; Chong Yidong <cyd@stupidchicken.com>
;; Maintainer: Chong Yidong <cyd@stupidchicken.com>
;; 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, 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; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, 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. 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:
(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."
:group 'longlines
: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."
:group 'longlines
: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'."
:group 'longlines
: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."
:group '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 Long Lines mode, 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."
:group 'longlines :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)
(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)
(after-change-functions nil)
(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)
(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-to-list 'message-indent-citation-function
'longlines-decode-region 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)
(after-change-functions nil)
(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 '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))
(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)
(progn (insert-before-markers ?\n)
(backward-char 1)
(delete-char -1)
(forward-char 1)
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))))
(insert-before-markers-and-inherit ?\s)
(backward-char 1)
(delete-char -1)
(forward-char 1))
nil)
(forward-line 1)
t)))
(defun longlines-set-breakpoint ()
"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 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
(run-hook-with-args-until-success
'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
(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)
(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 (&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)
"Replace each soft newline between BEG and END with exactly one space.
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)
(unless (get-text-property (match-beginning 0) 'hard)
(replace-match " ")))
(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-match "\n" str)))
(while pos
(if (null (get-text-property pos 'hard str))
(aset str pos ? ))
(setq pos (string-match "\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
(isearch-word
(if isearch-forward 'word-search-forward 'word-search-backward))
(isearch-regexp
(if isearch-forward 're-search-forward 're-search-backward))
(t
(if isearch-forward
'longlines-search-forward
'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)))
;; 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))
(provide 'longlines)
;; arch-tag: 3489d225-5506-47b9-8659-d8807b77c624
;;; longlines.el ends here
[-- Attachment #3: Type: text/plain, Size: 152 bytes --]
_______________________________________________
help-gnu-emacs mailing list
help-gnu-emacs@gnu.org
http://lists.gnu.org/mailman/listinfo/help-gnu-emacs
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: longlines and global-auto-revert-mode
2008-01-16 10:55 ` martin rudalics
@ 2008-01-16 12:29 ` Dmitry Bolshakov
0 siblings, 0 replies; 5+ messages in thread
From: Dmitry Bolshakov @ 2008-01-16 12:29 UTC (permalink / raw)
To: martin rudalics; +Cc: help-gnu-emacs
> > I coud not apply patch:
>
> I was afraid it won't. I'll attach my current version of longlines.el,
> please try it. If the byte-compiler gets you an error I have to find
> the version of this in emacs 22.1 and patch it. But that version has
> some other bugs in this context, hence it's maybe not reasonably to use.
>
> If you want to fix that manually: FWIW the bug is caused by the fact
> that before reverting the buffer longlines-mode wants to remove its
> newlines. At this time your file has already changed on disk, Emacs
> notices that and tells you about it. By binding `buffer-file-name' and
> `buffer-file-truename' to nil while removing these newlines you should
> be able to trick Emacs into believing that the buffer is not associated
> with any file and so not ask any questions.
>
> Sorry, it's a never-ending story with this problem.
>
Wow! It works. Compilation was successful. Many thanks!
--
With best regards
Dmitry Bolshakov
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2008-01-16 12:29 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2008-01-15 10:01 longlines and global-auto-revert-mode Dmitry Bolshakov
-- strict thread matches above, loose matches on Subject: below --
2008-01-15 17:35 martin rudalics
2008-01-16 10:07 ` Dmitry Bolshakov
2008-01-16 10:55 ` martin rudalics
2008-01-16 12:29 ` Dmitry Bolshakov
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.