1
0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-12-04 08:47:11 +00:00
emacs/lisp/textmodes/two-column.el
1992-09-28 13:02:35 +00:00

620 lines
25 KiB
EmacsLisp
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;;; two-column.el --- minor mode for editing of two-column text
;; Copyright (C) 1992 Free Software Foundation, Inc.
;; Author: Daniel Pfeiffer <pfeiffer@cix.cict.fr>
;; Adapted-By: ESR
;; 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
;;; Commentary:
;; --8<---- two-column.el ----8<--------8<--------8<--------8<--------8<-------
;; Esperanto: English:
;; Minora modalo por samtempa dukolumna Minor mode for simultaneous
;; tajpado two-column editing
;; ^Ci dataro estas ero de GNU Emacs. This file is part of GNU Emacs.
;; GNU Emacs estas disdonata en la GNU Emacs is distributed in the hope
;; espero ke ^gi estos utila, sed SEN that it will be useful, but WITHOUT
;; IA GARANTIO. Neniu a^utoro a^u ANY WARRANTY. No author or
;; disdonanto akceptas respondecon al distributor accepts responsibility
;; iu ajn por la sekvoj de ^gia uzado, to anyone for the consequences of
;; a^u ^cu ^gi serveblas al iu celo, using it or for whether it serves
;; a^u e^c entute funkcias, se li ni any particular purpose or works at
;; estas skribinta tion. Vidu la GNU all, unless he says so in writing.
;; Emacs ^Generala Publika Licenco por Refer to the GNU Emacs General
;; plenaj detaloj. Public License for full details.
;; ^Ciu rajtas kopii, modifi kaj ree Everyone is granted permission to
;; disdoni GNU Emacs, sed nur sub la copy, modify and redistribute GNU
;; condi^coj priskribitaj en la GNU Emacs, but only under the conditions
;; Emacs ^Generala Publika Licenco. described in the GNU Emacs General
;; Kopio de tiu licenso estas supozata Public License. A copy of this
;; donita al vi kune kun GNU Emacs, por license is supposed to have been
;; ke vi sciu viajn rajtojn kaj given to you along with GNU Emacs so
;; respondecojn. ^Gi devus esti en you can know your rights and
;; dataro nomata COPYING. Inter responsibilities. It should be in a
;; alia^joj, la notico pri kopirajto file named COPYING. Among other
;; kaj ^ci notico devas esti gardata things, the copyright notice and
;; sur ^ciuj kopioj. this notice must be preserved on all
;; copies.
;; Tiu minora modalo ebligas al vi This minor mode allows you to
;; tajpi sendepende en du apudaj independently edit two adjacent
;; bufroj. Vi havas tri eblecojn por buffers. You have three ways to
;; eki ^gin. ^Ciu donas al vi start it up. Each gives you a
;; horizontale disigatan fenestron, horizontally split window similar to
;; simila al fina apareco de via the final outcome of your text:
;; teksto:
;; C-x 6 2 asocias novan bufron nomatan associates a new buffer called
;; same, sed kun 2C/ anta^u. the same, but with 2C/
;; prepended.
;; C-x 6 b asocias alian bufron. Vi povas associates another buffer.
;; anka^u asocii dataron, se vi This can be used to associate a
;; ^jus anta^ue faris C-x C-f. file if you just did C-x C-f.
;; C-x 6 u disigas jam dukolumnan tekston unmerges a two-column text into
;; en du bufroj ekde la nuna two buffers from the current
;; linio, kaj je la nuna kolumno. line and at the current column.
;; La anta^uaj signoj (ofte The preceding characters (often
;; tabeligilo a^u |) estas la tab or |) are the column
;; kolumna disiganto. Linioj kiuj separator. Lines that don't
;; ne enhavas ilin ne estas have them won't be separated.
;; disigitaj. Kiel la kvara kaj Like the fourth and fifth line
;; la kvina linio se vi disigas if you unmerge this file from
;; ^ci dataron ekde la unua angla the first english word.
;; vorto.
;; Je ^cia flanko estas bufro, kiu On each side is a buffer that knows
;; konas la alian. Kun la ordonoj C-x about the other. With the commands
;; 6 SPC, C-x 6 DEL kaj C-x 6 RET oni C-x 6 SPC, C-x 6 DEL and C-x 6 RET
;; povas suben- a^u supreniri unu you can simultaneously scroll up or
;; ekranon, kaj subeniri linion, down by a screenfull and by a line
;; samtempe en la du bufroj. Al la alia in both buffers. Empty lines are
;; bufro estas aldonataj linioj se added to the other buffer if
;; necesas, por ke vi vidu la saman necessary, so that you see the same
;; parton. Per C-x 6 C-l vi povas part. With C-x 6 C-l you can
;; recentrigi la linion. Kiam vi nur recenter the line. When you only
;; plu havas unu el la du bufroj have one of the two buffers onscreen
;; surekrane vi revidos la alian per you can get the other back with C-x
;; denove C-x 6 2. 6 2 once more.
;; Se vi volas meti longajn liniojn If you include long lines, i.e which
;; (ekz. programerojn) en la kunigotan will span both columns (eg. source
;; tekston, ili devas esti en la code), they should be in what will
;; estonte unua kolumno. La alia devas be the first column, with the
;; havi malplenajn linion apud ili. associated buffer having empty lines
;; next to them.
;; Averto: en Emacs kiam vi ^san^gas la Attention: in Emacs when you change
;; ma^joran modalon, la minoraj modaloj the major mode, the minor modes are
;; estas anka^u elmemorigitaj. Tiu- also purged from memory. In that
;; okaze vi devas religi la du bufrojn case you must reassociate the two
;; per iu C-x 6-ordono, ekz. C-x 6 b. buffers with any C-x 6-command, e.g.
;; C-x 6 b.
;; Kiam vi estos kontenta de la When you have edited both buffers to
;; rezulto, vi kunmetos la du kolumnojn your content, you merge them with
;; per C-x 6 1. Se vi poste vidas C-x 6 1. If you then see a problem,
;; problemon, vi neniigu la kunmeton you undo the merge with C-x u and
;; per C-x u kaj plue modifu la du continue to edit the two buffers.
;; bufrojn. Kiam vi ne plu volas tajpi When you no longer want to edit in
;; dukolumne, vi eliru el la minora two columns, you turn off the minor
;; modalo per C-x 6 k. mode with C-x 6 k.
;; An^stata^u tri `autoload' kaj tri | Instead of three `autoload' and
;; `global-set-key' vi povas uzi la | three `global-set-key' you can use
;; jenon en via dataro ~/.emacs, por | the following in your file
;; memstare ^car^gi la modalon: | ~/.emacs, to automatically load
;; | the mode:
;; (global-set-key "\C-x6"
;; '(lambda () (interactive)
;; (load-library "two-column")
;; (call-interactively
;; (cdr (assq (read-char) tc-mode-map)))))
;; Se vi ^satus havi la dukolumnajn | If you'd like to have the
;; ordonojn je funkciklavo <f2>, vi | two-column commands on function
;; povas uzi la jenon en via dataro | key <f2>, you can use the
;; ~/.emacs: | following in your file ~/.emacs:
;; (global-set-key [f2] (function
;; (lambda ()
;; (interactive)
;; (load-library "two-column")
;; (global-set-key [f2] tc-mode-map)
;; (call-interactively
;; (cdr (assq (read-char) tc-mode-map))))))
;; In addition to two-column editing of text, for example for writing a
;; bilingual text side-by-side as shown below in the file's prolog, other
;; interesting uses have been found for this minor mode:
;;
;;
;; You can separate the columns with {+} C-x 6 u or <f2> u if you prefer
;; any string that pleases you, by {+} handles these with a prefix argument
;; setting tc-separator. For {+} that enables you to declare the
;; example "{+} " if you like to {+} desired length of such a string.
;; amuse yourself.
;;
;;
;; keyword You can write any text corresponding to a
;; given keyword in a filled paragraph next to
;; it. Note that the width of the first column
;; may be less than window-min-width in the
;; result, but will be displayed at that width.
;;
;; another This is not a three- or multi-column mode.
;; The example in the file's prolog required
;; working on two columns and then treating the
;; result as one column in order to add the
;; third.
;;
;;
;; Programmers might like the ability to split off the comment column of
;; a file that looks like the following. The advantage is that with
;; (setq fill-prefix "-- ") you can run M-q (fill-paragraph) on the
;; comment. The problem is, code quickly gets rather wide, so you need
;; to use a narrower comment column, which is less interesting, unless
;; you have a 132-column screen. Code lines that reach beyond
;; comment-column are no problem, except that you won't always see their
;; end during editing.
;;
;; BEGIN -- This is just some meaningless
;; FOR i IN 1..10 LOOP -- code in Ada, that runs foobar
;; foobar( i ); -- once for each argument from one
;; END LOOP; -- to ten, and then we're already
;; END; -- through with it.
;;
;; Better yet, you can put the point before "This", type M-3 C-x 6 u
;; which makes "-- " the separator between a no-comments Ada buffer, and
;; a plain text comment buffer. When you put them back together, every
;; non-empty line of the 2nd column will again be preceded by "-- ".
;;
;;
;; The <f2> function key hack (which is one of the rare times when
;; function keys are mnemonic) at the end of the file's prolog requires
;; that the lisp/term/*.el for your terminal use the standard
;; conventions. Too bad that some don't (at least not in version 18.55).
;; The Sun one is hopelessly non-standard, and vt2[024]0 somehow forgot
;; to define <f1> thru <f5>. (It defines <pf1> thru <pf4> instead, but
;; that is not what we need on an X terminal.) If you want to use those,
;; you'll need another hack something like:
;;
;; (if (string= (system-name) "cix")
;; (progn
;; (load-library "term/vt200.el")
;; (define-key CSI-map "12~" (cons function-keymap ?\^b)))
;; (global-unset-key "\e[")
;; (define-key esc-map "[225z" (cons function-keymap ?\^b)))
;;
;; where "cix" is the non-sun machine I use. Actually I use the same X
;; terminal to connect to both machines, and I want to keep my ~/.emacs
;; identical on both. Bother, the two Emacses don't recognize the same
;; keys and assign different sequences to those they do! I sure hope all
;; this nonsense will stop with version 19 (or preferably soon) where I'd
;; like to be able to say (define-key some-map '<f2> some-cmd), and see
;; <f2> rather than some unintelligible ESC-sequence in command key
;; sequences.
;;; Code:
;;;;; Set up keymap ;;;;;
;;;###autoload
(defvar tc-mode-map nil
"Keymap for commands for two-column mode.")
;;;###autoload
(if tc-mode-map
()
(setq tc-mode-map (make-sparse-keymap))
(define-key tc-mode-map "1" 'tc-merge)
(define-key tc-mode-map "2" 'tc-two-columns)
(define-key tc-mode-map "b" 'tc-associate-buffer)
(define-key tc-mode-map "k" 'tc-kill-association)
(define-key tc-mode-map "\C-l" 'tc-recenter)
(define-key tc-mode-map "o" 'tc-associated-buffer)
(define-key tc-mode-map "s" 'tc-split)
(define-key tc-mode-map "{" 'shrink-window-horizontally)
(define-key tc-mode-map "}" 'enlarge-window-horizontally)
(define-key tc-mode-map " " 'tc-scroll-up)
(define-key tc-mode-map "\^?" 'tc-scroll-down)
(define-key tc-mode-map "\C-m" 'tc-scroll-line))
;;;###autoload
(global-set-key "\C-x6" tc-mode-map)
;;;;; variable declarations ;;;;;
;; markers seem to be the only buffer-id not affected by renaming
;; a buffer. This nevertheless loses when a buffer is killed.
(defvar tc-other nil
"Marker to the associated buffer, if non-nil.")
(make-variable-buffer-local 'tc-other)
(put 'tc-other 'permanent-local t)
(setq minor-mode-alist (cons '(tc-other " 2C") minor-mode-alist))
;; rearranged, so that the pertinent info will show in 40 columns
(defvar tc-mode-line-format
'("-%*- %15b --" (-3 . "%p") "--%[(" mode-name
minor-mode-alist "%n" mode-line-process ")%]%-")
"*Value of mode-line-format for a buffer in two-column minor mode.")
(defvar tc-separator ""
"*A string inserted between the two columns when merging.
This gets set locally by \\[tc-split].")
(put 'tc-separator 'permanent-local t)
(defvar tc-window-width 40
"*The width of the first column. (Must be at least `window-min-width')
This value is local for every buffer that sets it.")
(make-variable-buffer-local 'tc-window-width)
(put 'tc-window-width 'permanent-local t)
(defvar tc-beyond-fill-column 4
"*Base for calculating `fill-column' for a buffer in two-column minor mode.
The value of `fill-column' becomes `tc-window-width' for this buffer
minus this value.")
(defvar tc-mode-hook nil
"Function called, if non-nil, whenever turning on two-column minor mode.
It can get called by \\[tc-two-columns] (tc-two-columns), \\[tc-split] (tc-split)
and \\[tc-associate-buffer] (tc-associate-buffer), on both buffers.")
;;;;; base functions ;;;;;
;; the access method for the other buffer. this tries to remedy against
;; lost local variables and lost buffers.
(defun tc-other ()
(if tc-other
(or (prog1
(marker-buffer tc-other)
(setq mode-line-format tc-mode-line-format ))
; The associated buffer somehow got killed.
(progn
; The other variables may later be useful if the user
; reestablishes the association.
(kill-local-variable 'tc-other)
(kill-local-variable 'mode-line-format)
nil))))
(defun tc-two-columns (&optional buffer)
"Split current window vertically for two-column editing.
When called the first time, associates a buffer with the current
buffer. Both buffers are put in two-column minor mode and
tc-mode-hook gets called on both. These buffers remember
about one another, even when renamed.
When called again, restores the screen layout with the current buffer
first and the associated buffer to it's right.
If you include long lines, i.e which will span both columns (eg.
source code), they should be in what will be the first column, with
the associated buffer having empty lines next to them.
You have the following commands at your disposal:
\\[tc-two-columns] Rearrange screen
\\[tc-associate-buffer] Reassociate buffer after changing major mode
\\[tc-scroll-up] Scroll both buffers up by a screenfull
\\[tc-scroll-down] Scroll both buffers down by a screenful
\\[tc-scroll-line] Scroll both buffers up by one or more lines
\\[tc-recenter] Recenter and realign other buffer
\\[shrink-window-horizontally], \\[enlarge-window-horizontally] Shrink, enlarge current column
\\[tc-associated-buffer] Switch to associated buffer
\\[tc-merge] Merge both buffers
These keybindings can be customized in your ~/.emacs by `tc-prefix'
and `tc-mode-map'.
The appearance of the screen can be customized by the variables
`tc-window-width', `tc-beyond-fill-column',
`tc-mode-line-format' and `truncate-partial-width-windows'."
(interactive "P")
; first go to full width, so that we can certainly split into
; two windows
(if (< (window-width) (frame-width))
(enlarge-window 99999 t))
(split-window-horizontally
(max window-min-width (min tc-window-width
(- (frame-width) window-min-width))))
(if (tc-other)
(progn
(other-window 1)
(switch-to-buffer (tc-other))
(other-window -1)
; align buffers if necessary
(tc-scroll-line 0))
; set up minor mode linking two buffers
(setq fill-column (- tc-window-width
tc-beyond-fill-column)
mode-line-format tc-mode-line-format)
(run-hooks tc-mode-hook)
(let ((other (point-marker)))
(other-window 1)
(switch-to-buffer
(or buffer
(generate-new-buffer
(concat "2C/" (buffer-name)))))
(or buffer
(text-mode))
(setq fill-column (- tc-window-width
tc-beyond-fill-column)
mode-line-format tc-mode-line-format
tc-other other
other (point-marker))
(run-hooks tc-mode-hook)
(other-window -1)
(setq tc-other other))))
(fset 'tc-mode 'tc-two-columns)
(defun tc-associate-buffer ()
"Associate another buffer with this one in two-column minor mode.
Can also be used to associate a just previously visited file, by
accepting the proposed default buffer.
See \\[tc-two-columns] and `lisp/two-column.el' for further details."
(interactive)
(let ((b1 (current-buffer))
(b2 (or (tc-other)
(read-buffer "Associate buffer: " (other-buffer)))))
(save-excursion
(setq tc-other nil)
(set-buffer b2)
(and (tc-other)
(not (eq b1 (tc-other)))
(error "Buffer already associated with buffer `%s'."
(buffer-name (tc-other))))
(setq b1 (and (assq 'tc-window-width (buffer-local-variables))
tc-window-width)))
; if other buffer has a local width, adjust here too
(if b1 (setq tc-window-width (- (frame-width) b1)))
(tc-two-columns b2)))
(defun tc-split (arg)
"Unmerge a two-column text into two buffers in two-column minor mode.
The text is unmerged at the cursor's column which becomes the local
value of `tc-window-width'. Only lines that have the ARG same
preceding characters at that column get split. The ARG preceding
characters without any leading whitespace become the local value for
`tc-separator'. This way lines that continue across both
columns remain untouched in the first buffer.
This function can be used with a prototype line, to set up things as
you like them. You write the first line of each column with the
separator you like and then unmerge that line. E.g.:
First column's text sSs Second columns text
\\___/\\
/ \\
5 character Separator You type M-5 \\[tc-split] with the point here
See \\[tc-two-columns] and `lisp/two-column.el' for further details."
(interactive "p")
(and (tc-other)
(if (y-or-n-p (concat "Overwrite associated buffer `"
(buffer-name (tc-other))
"'? "))
(save-excursion
(set-buffer (tc-other))
(erase-buffer))
(signal 'quit nil)))
(let ((point (point))
; make next-line always come back to same column
(goal-column (current-column))
; a counter for empty lines in other buffer
(n (1- (count-lines (point-min) (point))))
chars other)
(save-excursion
(backward-char arg)
(setq chars (buffer-substring (point) point))
(skip-chars-forward " \t" point)
(make-local-variable 'tc-separator)
(setq tc-separator (buffer-substring (point) point)
tc-window-width (current-column)))
(tc-two-columns)
(setq other (tc-other))
; now we're ready to actually unmerge
(save-excursion
(while (not (eobp))
(if (not (and (= (current-column) goal-column)
(string= chars
(buffer-substring (point)
(save-excursion
(backward-char arg)
(point))))))
(setq n (1+ n))
(setq point (point))
(backward-char arg)
(skip-chars-backward " \t")
(delete-region point (point))
(setq point (point))
(insert-char ?\n n)
(append-to-buffer other point (progn (end-of-line)
(if (eobp)
(point)
(1+ (point)))))
(delete-region point (point))
(setq n 0))
(next-line 1)))))
(defun tc-kill-association ()
"Turn off two-column minor mode in current and associated buffer.
If the associated buffer is unmodified and empty, it is killed."
(interactive)
(let ((buffer (current-buffer)))
(save-excursion
(and (tc-other)
(set-buffer (tc-other))
(or (not (tc-other))
(eq buffer (tc-other)))
(if (and (not (buffer-modified-p))
(eobp) (bobp))
(kill-buffer nil)
(kill-local-variable 'tc-other)
(kill-local-variable 'tc-window-width)
(kill-local-variable 'tc-separator)
(kill-local-variable 'mode-line-format)
(kill-local-variable 'fill-column))))
(kill-local-variable 'tc-other)
(kill-local-variable 'tc-window-width)
(kill-local-variable 'tc-separator)
(kill-local-variable 'mode-line-format)
(kill-local-variable 'fill-column)))
;; this doesn't use yank-rectangle, so that the first column can
;; contain long lines
(defun tc-merge ()
"Merges the associated buffer with the current buffer.
They get merged at the column, which is the value of
`tc-window-width', i.e. usually at the vertical window
separator. This separator gets replaced with white space. Beyond
that the value of gets inserted on merged lines. The two columns are
thus pasted side by side, in a single text. If the other buffer is
not displayed to the left of this one, then this one becomes the left
column.
If you want `tc-separator' on empty lines in the second column,
you should put just one space in them. In the final result, you can strip
off trailing spaces with \\[beginning-of-buffer] \\[replace-regexp] [ SPC TAB ] + $ RET RET"
(interactive)
(or (tc-other)
(error "You must first set two-column minor mode."))
(and (> (car (window-edges)) 0) ; not touching left edge of screen
(eq (window-buffer (previous-window))
(tc-other))
(other-window -1))
(save-excursion
(let ((b1 (current-buffer))
(b2 (tc-other))
string)
(goto-char (point-min))
(set-buffer b2)
(goto-char (point-min))
(while (not (eobp))
(setq string (buffer-substring (point)
(progn (end-of-line) (point))))
(or (eobp)
(forward-char)) ; next line
(set-buffer b1)
(if (string= string "")
()
(end-of-line)
(indent-to-column tc-window-width)
(insert tc-separator string))
(next-line 1) ; add one if necessary
(set-buffer b2))))
(if (< (window-width) (frame-width))
(enlarge-window 99999 t)))
;;;;; utility functions ;;;;;
(defun tc-associated-buffer ()
"Switch to associated buffer."
(interactive)
(or (tc-other)
(error "You must set two-column minor mode."))
(if (get-buffer-window (tc-other))
(select-window (get-buffer-window (tc-other)))
(switch-to-buffer (tc-other))))
;; It would be desirable to intercept anything that causes the current
;; window to scroll. Maybe a `scroll-hook'?
(defun tc-scroll-line (arg)
"Scroll current window upward by ARG lines.
The associated window gets scrolled to the same line."
(interactive "p")
(or (tc-other)
(error "You must set two-column minor mode."))
; scroll-up has a bug on arg 0 at end of buffer
(or (zerop arg)
(scroll-up arg))
(setq arg (count-lines (point-min) (window-start)))
; too bad that pre 18.57 Emacs makes save-window-excursion restore
; the point. When it becomes extinct, we can simplify this.
(if (get-buffer-window (tc-other))
(let ((window (selected-window)))
(select-window (get-buffer-window (tc-other)))
(setq arg (- arg (count-lines (point-min) (window-start))))
; make sure that other buffer has enough lines
(save-excursion
(goto-char (point-max))
(insert-char ?\n
(- arg (count-lines (window-start) (point-max)) -1)))
(or (zerop arg)
(scroll-up arg))
(select-window window))))
(defun tc-scroll-up (arg)
"Scroll current window upward by ARG screens.
The associated window gets scrolled to the same line."
(interactive "p")
(tc-scroll-line (* arg (- (window-height)
next-screen-context-lines 1))))
(defun tc-scroll-down (arg)
"Scroll current window downward by ARG screens.
The associated window gets scrolled to the same line."
(interactive "p")
(tc-scroll-line (* arg (- next-screen-context-lines
(window-height) -1))))
(defun tc-recenter (arg)
"Center point in window. With ARG, put point on line ARG.
This counts from bottom if ARG is negative. The associated window
gets scrolled to the same line."
(interactive "P")
(setq arg (and arg (prefix-numeric-value arg)))
(tc-scroll-line (- (count-lines (window-start) (point))
(cond ((null arg) (/ (window-height) 2))
((< arg 0) (+ (window-height) arg))
( arg)))))
(defun enlarge-window-horizontally (arg)
"Make current window ARG columns wider."
(interactive "p")
(enlarge-window arg t)
(and (tc-other)
(setq tc-window-width (+ tc-window-width arg))
(set-buffer (tc-other))
(setq tc-window-width (- tc-window-width arg))))
(defun shrink-window-horizontally (arg)
"Make current window ARG columns narrower."
(interactive "p")
(enlarge-window-horizontally (- arg)))
(provide 'two-column)
;;; two-column.el ends here