Fix maintainer address.
[emacs.git] / lisp / textmodes / page-ext.el
blob1cbb1f425063e6cb2e2de2215a895a220fb564ad
1 ;;; page-ext.el --- extended page handling commands
3 ;; Copyright (C) 1990, 1991, 1993, 1994 Free Software Foundation
5 ;; Maintainer: Robert J. Chassell <bob@gnu.org>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 2, or (at your option)
12 ;; any later version.
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 ;; Boston, MA 02111-1307, USA.
24 ;;; Commentary:
26 ;; You may use these commands to handle an address list or other
27 ;; small data base.
30 ;;; Summary
32 ;; The current page commands are:
34 ;; forward-page C-x ]
35 ;; backward-page C-x [
36 ;; narrow-to-page C-x p
37 ;; count-lines-page C-x l
38 ;; mark-page C-x C-p (change this to C-x C-p C-m)
39 ;; sort-pages not bound
40 ;; what-page not bound
42 ;; The new page handling commands all use `C-x C-p' as a prefix. This
43 ;; means that the key binding for `mark-page' must be changed.
44 ;; Otherwise, no other changes are made to the current commands or
45 ;; their bindings.
47 ;; New page handling commands:
49 ;; next-page C-x C-p C-n
50 ;; previous-page C-x C-p C-p
51 ;; search-pages C-x C-p C-s
52 ;; add-new-page C-x C-p C-a
53 ;; sort-pages-buffer C-x C-p s
54 ;; set-page-delimiter C-x C-p C-l
55 ;; pages-directory C-x C-p C-d
56 ;; pages-directory-for-addresses C-x C-p d
57 ;; pages-directory-goto C-c C-c
60 ;;; Using the page commands
62 ;; The page commands are helpful in several different contexts. For
63 ;; example, programmers often divide source files into sections using the
64 ;; `page-delimiter'; you can use the `pages-directory' command to list
65 ;; the sections.
67 ;; You may change the buffer local value of the `page-delimiter' with
68 ;; the `set-page-delimiter' command. This command is bound to `C-x C-p
69 ;; C-l' The command prompts you for a new value for the page-delimiter.
70 ;; Called with a prefix-arg, the command resets the value of the
71 ;; page-delimiter to its original value.
73 ;; You may set several user options:
75 ;; The `pages-directory-buffer-narrowing-p' variable causes the
76 ;; `pages-directory-goto' command to narrow to the destination page.
78 ;; The `pages-directory-for-adding-page-narrowing-p' variable, causes the
79 ;; `add-new-page' command to narrow to the new entry.
81 ;; The `pages-directory-for-adding-new-page-before-current-page-p' variable
82 ;; causes the `add-new-page' command to insert a new page before current
83 ;; page.
85 ;; These variables are true by default.
87 ;; Additional, addresses-related user options are described in the next page
88 ;; of this file.
91 ;;; Handling an address list or small data base
93 ;; You may use the page commands to handle an address list or other
94 ;; small data base. Put each address or entry on its own page. The
95 ;; first line of text in each page is a `header line' and is listed by
96 ;; the `pages-directory' or `pages-directory-for-addresses' command.
98 ;; Specifically:
99 ;;
100 ;; 1. Begin each entry with a `page-delimiter' (which is, by default,
101 ;; `^L' at the beginning of the line).
103 ;; 2. The first line of text in each entry is the `heading line'; it
104 ;; will appear in the pages-directory-buffer which is constructed
105 ;; using the `C-x C-p C-d' (pages-directory) command or the `C-x
106 ;; C-p d' (pages-directory-for-addresses) command.
108 ;; The heading line may be on the same line as the page-delimiter
109 ;; or it may follow after. It is the first non-blank line on the
110 ;; page. Conventionally, the heading line is placed on the line
111 ;; immediately following the line containing page-delimiter.
113 ;; 3. Follow the heading line with the body of the entry. The body
114 ;; extends up to the next `page-delimiter'. The body may be of any
115 ;; length. It is conventional to place a blank line after the last
116 ;; line of the body.
118 ;; For example, a file might look like this:
120 ;; FSF
121 ;; Free Software Foundation
122 ;; 59 Temple Place - Suite 330
123 ;; Boston, MA 02111-1307 USA.
124 ;; (617) 542-5942
125 ;; gnu@gnu.org
127 ;; \f
128 ;; House Subcommittee on Intellectual Property,
129 ;; U.S. House of Representatives,
130 ;; Washington, DC 20515
132 ;; Congressional committee concerned with permitting or preventing
133 ;; monopolistic restrictions on the use of software technology.
135 ;; \f
136 ;; George Lakoff
137 ;; ``Women, Fire, and Dangerous Things:
138 ;; What Categories Reveal about the Mind''
139 ;; 1987, Univ. of Chicago Press
141 ;; About philosophy, Whorfian effects, and linguistics.
143 ;; \f
144 ;; OBI (On line text collection.)
145 ;; Open Book Initiative
146 ;; c/o Software Tool & Die
147 ;; 1330 Beacon St, Brookline, MA 02146 USA
148 ;; (617) 739-0202
149 ;; obi@world.std.com
151 ;; In this example, the heading lines are:
153 ;; FSF
154 ;; House Subcommittee on Intellectual Property
155 ;; George Lakoff
156 ;; OBI (On line text collection.)
158 ;; The `C-x C-p s' (sort-pages-buffer) command sorts the entries in the
159 ;; buffer alphabetically.
161 ;; You may use any of the page commands, including the `next-page',
162 ;; `previous-page', `add-new-page', `mark-page', and `search-pages'
163 ;; commands.
165 ;; You may use either the `C-x C-p d' (pages-directory-for-addresses)
166 ;; or the `C-x C-p C-d' (pages-directory) command to construct and
167 ;; display a directory of all the heading lines.
169 ;; In the directory, you may position the cursor over a heading line
170 ;; and type `C-c C-c' (pages-directory-goto) to go to the entry to
171 ;; which it refers in the pages buffer.
173 ;; You can type `C-c C-p C-a' (add-new-page) to add a new entry in the
174 ;; pages buffer or address file. This is the same command you use to
175 ;; add a new entry when you are in the pages buffer or address file.
177 ;; If you wish, you may create several different directories,
178 ;; one for each different buffer.
180 ;; `pages-directory-for-addresses' in detail
182 ;; The `pages-directory-for-addresses' assumes a default addresses
183 ;; file. You do not need to specify the addresses file but merely type
184 ;; `C-x C-p d' from any buffer. The command finds the file, constructs
185 ;; a directory for it, and switches you to the directory. If you call
186 ;; the command with a prefix arg, `C-u C-x C-p d', it prompts you for a
187 ;; file name.
189 ;; You may customize the addresses commands:
191 ;; The `pages-addresses-file-name' variable determines the name of
192 ;; the addresses file; by default it is "~/addresses".
194 ;; The `pages-directory-for-addresses-goto-narrowing-p' variable
195 ;; determines whether `pages-directory-goto' narrows the addresses
196 ;; buffer to the entry, which it does by default.
198 ;; The `pages-directory-for-addresses-buffer-keep-windows-p' variable
199 ;; determines whether `pages-directory-for-addresses' deletes other
200 ;; windows to show as many lines as possible on the screen or works
201 ;; in the usual Emacs manner and keeps other windows. Default is to
202 ;; keep other windows.
204 ;; The `pages-directory-for-adding-addresses-narrowing-p' variable
205 ;; determines whether `pages-directory-for-addresses' narrows the
206 ;; addresses buffer to a new entry when you are adding that entry.
207 ;; Default is to narrow to new entry, which means you see a blank
208 ;; screen before you write the new entry.
210 ;; `pages-directory' in detail
212 ;; Call the `pages-directory' command from the buffer for which you
213 ;; want a directory created; it creates a directory for the buffer and
214 ;; pops you to the directory.
216 ;; The `pages-directory' command has several options:
218 ;; Called with a prefix arg, `C-u C-x C-p C-d', the `pages-directory'
219 ;; prompts you for a regular expression and only lists only those
220 ;; header lines that are part of pages that contain matches to the
221 ;; regexp. In the example above, `C-u C-x C-p C-d 617 RET' would
222 ;; match the telephone area code of the first and fourth entries, so
223 ;; only the header lines of those two entries would appear in the
224 ;; pages-directory-buffer.
226 ;; Called with a numeric argument, the `pages-directory' command
227 ;; lists the number of lines in each page. This is helpful when you
228 ;; are printing hardcopy.
230 ;; Called with a negative numeric argument, the `pages-directory'
231 ;; command lists the lengths of pages whose contents match a regexp.
233 ;;; Code:
236 ;;; Customarily customizable variable definitions
238 (defgroup pages nil
239 "Extended page-handling commands."
240 :group 'extensions)
243 (defcustom pages-directory-buffer-narrowing-p t
244 "*If non-nil, `pages-directory-goto' narrows pages buffer to entry."
245 :type 'boolean
246 :group 'pages)
248 (defcustom pages-directory-for-adding-page-narrowing-p t
249 "*If non-nil, `add-new-page' narrows page buffer to new entry."
250 :type 'boolean
251 :group 'pages)
253 (defcustom pages-directory-for-adding-new-page-before-current-page-p t
254 "*If non-nil, `add-new-page' inserts new page before current page."
255 :type 'boolean
256 :group 'pages)
259 ;;; Addresses related variables
261 (defcustom pages-addresses-file-name "~/addresses"
262 "*Standard name for file of addresses. Entries separated by page-delimiter.
263 Used by `pages-directory-for-addresses' function."
264 :type 'file
265 :group 'pages)
267 (defcustom pages-directory-for-addresses-goto-narrowing-p t
268 "*If non-nil, `pages-directory-goto' narrows addresses buffer to entry."
269 :type 'boolean
270 :group 'pages)
272 (defcustom pages-directory-for-addresses-buffer-keep-windows-p t
273 "*If nil, `pages-directory-for-addresses' deletes other windows."
274 :type 'boolean
275 :group 'pages)
277 (defcustom pages-directory-for-adding-addresses-narrowing-p t
278 "*If non-nil, `add-new-page' narrows addresses buffer to new entry."
279 :type 'boolean
280 :group 'pages)
283 ;;; Key bindings for page handling functions
285 (global-unset-key "\C-x\C-p")
287 (defvar ctl-x-ctl-p-map (make-sparse-keymap)
288 "Keymap for subcommands of C-x C-p, which are for page handling.")
290 (define-key ctl-x-map "\C-p" 'ctl-x-ctl-p-prefix)
291 (fset 'ctl-x-ctl-p-prefix ctl-x-ctl-p-map)
293 (define-key ctl-x-ctl-p-map "\C-n" 'next-page)
294 (define-key ctl-x-ctl-p-map "\C-p" 'previous-page)
295 (define-key ctl-x-ctl-p-map "\C-a" 'add-new-page)
296 (define-key ctl-x-ctl-p-map "\C-m" 'mark-page)
297 (define-key ctl-x-ctl-p-map "\C-s" 'search-pages)
298 (define-key ctl-x-ctl-p-map "s" 'sort-pages-buffer)
299 (define-key ctl-x-ctl-p-map "\C-l" 'set-page-delimiter)
300 (define-key ctl-x-ctl-p-map "\C-d" 'pages-directory)
301 (define-key ctl-x-ctl-p-map "d" 'pages-directory-for-addresses)
304 ;;; Page movement function definitions
306 (defun next-page (&optional count)
307 "Move to the next page bounded by the `page-delimiter' variable.
308 With arg (prefix if interactive), move that many pages."
309 (interactive "p")
310 (or count (setq count 1))
311 (widen)
312 ;; Cannot use forward-page because of problems at page boundaries.
313 (while (and (> count 0) (not (eobp)))
314 (if (re-search-forward page-delimiter nil t)
316 (goto-char (point-max)))
317 (setq count (1- count)))
318 ;; If COUNT is negative, we want to go back -COUNT + 1 page boundaries.
319 ;; The first page boundary we reach is the top of the current page,
320 ;; which doesn't count.
321 (while (and (< count 1) (not (bobp)))
322 (if (re-search-backward page-delimiter nil t)
323 (goto-char (match-beginning 0))
324 (goto-char (point-min)))
325 (setq count (1+ count)))
326 (narrow-to-page)
327 (goto-char (point-min))
328 (recenter 0))
330 (defun previous-page (&optional count)
331 "Move to the previous page bounded by the `page-delimiter' variable.
332 With arg (prefix if interactive), move that many pages."
333 (interactive "p")
334 (or count (setq count 1))
335 (next-page (- count)))
338 ;;; Adding and searching pages
340 (defun add-new-page (header-line)
341 "Insert new page. Prompt for header line.
343 If point is in the pages directory buffer, insert the new page in the
344 buffer associated with the directory.
346 Insert the new page just before current page if
347 pages-directory-for-adding-new-page-before-current-page-p variable
348 is non-nil. Else insert at exact location of point.
350 Narrow to new page if
351 pages-directory-for-adding-page-narrowing-p variable
352 is non-nil.
354 Page begins with a `^L' as the default page-delimiter.
355 Use \\[set-page-delimiter] to change the page-delimiter.
356 Point is left in the body of page."
357 (interactive "sHeader line: ")
358 (widen)
359 ;; If in pages directory buffer
360 (if (eq major-mode 'pages-directory-mode)
361 (progn
362 ;; Add new page before or after current page?
363 (if pages-directory-for-adding-new-page-before-current-page-p
364 (pages-directory-goto)
365 (pages-directory-goto)
366 (forward-page)
367 (or (eobp) (forward-line -1)))))
368 (widen)
369 ;; Move point before current delimiter if desired.
370 (and pages-directory-for-adding-new-page-before-current-page-p
371 (if (re-search-backward page-delimiter nil t)
372 (goto-char (match-beginning 0))
373 ;; If going to beginning of file, insert a page-delimiter
374 ;; before current first page.
375 (goto-char (point-min))
376 (insert
377 (format "%s\n"
378 ;; Remove leading `^' from page-delimiter string
379 (if (eq '^ (car (read-from-string page-delimiter)))
380 (substring page-delimiter 1))))
381 (goto-char (point-min))))
382 ;; Insert page delimiter at beginning of line.
383 (if (not (looking-at "^.")) (forward-line 1))
384 (insert (format "%s\n%s\n\n\n"
385 (if (eq '^ (car (read-from-string page-delimiter)))
386 (substring page-delimiter 1))
387 header-line))
388 (forward-line -1)
389 (and pages-directory-for-adding-page-narrowing-p (narrow-to-page)))
391 (defvar pages-last-search nil
392 "Value of last regexp searched for. Initially, nil.")
394 (defun search-pages (regexp)
395 "Search for REGEXP, starting from point, and narrow to page it is in."
396 (interactive (list
397 (read-string
398 (format "Search for `%s' (end with RET): "
399 (or pages-last-search "regexp")))))
400 (if (equal regexp "")
401 (setq regexp pages-last-search)
402 (setq pages-last-search regexp))
403 (widen)
404 (re-search-forward regexp)
405 (narrow-to-page))
408 ;;; Sorting pages
410 (autoload 'sort-subr "sort" "Primary function for sorting." t nil)
412 (defun sort-pages-in-region (reverse beg end)
413 "Sort pages in region alphabetically. Prefix arg means reverse order.
415 Called from a program, there are three arguments:
416 REVERSE (non-nil means reverse order), BEG and END (region to sort)."
418 ;;; This sort function handles ends of pages differently than
419 ;;; `sort-pages' and works better with lists of addresses and similar
420 ;;; files.
422 (interactive "P\nr")
423 (save-restriction
424 (narrow-to-region beg end)
425 (goto-char (point-min))
426 ;;; `sort-subr' takes three arguments
427 (sort-subr reverse
429 ;; NEXTRECFUN is called with point at the end of the
430 ;; previous record. It moves point to the start of the
431 ;; next record.
432 (function (lambda ()
433 (re-search-forward page-delimiter nil t)
434 (skip-chars-forward " \t\n")
437 ;; ENDRECFUN is is called with point within the record.
438 ;; It should move point to the end of the record.
439 (function (lambda ()
440 (if (re-search-forward
441 page-delimiter
444 (goto-char (match-beginning 0))
445 (goto-char (point-max))))))))
447 (defun sort-pages-buffer (&optional reverse)
448 "Sort pages alphabetically in buffer. Prefix arg means reverse order.
449 \(Non-nil arg if not interactive.\)"
451 (interactive "P")
452 (or reverse (setq reverse nil))
453 (widen)
454 (let ((beginning (point-min))
455 (end (point-max)))
456 (sort-pages-in-region reverse beginning end)))
459 ;;; Pages directory ancillary definitions
461 (defvar pages-directory-previous-regexp nil
462 "Value of previous regexp used by `pages-directory'.
463 \(This regular expression may be used to select only those pages that
464 contain matches to the regexp.\)")
466 (defvar pages-buffer nil
467 "The buffer for which the pages-directory function creates the directory.")
469 (defvar pages-directory-prefix "*Directory for:"
470 "Prefix of name of temporary buffer for pages-directory.")
472 (defvar pages-pos-list nil
473 "List containing the positions of the pages in the pages-buffer.")
475 (defvar pages-directory-map nil
476 "Keymap for the pages-directory-buffer.")
478 (if pages-directory-map
480 (setq pages-directory-map (make-sparse-keymap))
481 (define-key pages-directory-map "\C-c\C-c"
482 'pages-directory-goto)
483 (define-key pages-directory-map "\C-c\C-p\C-a" 'add-new-page)
484 (define-key pages-directory-map [mouse-2] 'pages-directory-goto-with-mouse))
486 (defvar original-page-delimiter "^\f"
487 "Default page delimiter.")
489 (defun set-page-delimiter (regexp reset-p)
490 "Set buffer local value of page-delimiter to REGEXP.
491 Called interactively with a prefix argument, reset `page-delimiter' to
492 its original value.
494 In a program, non-nil second arg causes first arg to be ignored and
495 resets the page-delimiter to the original value."
497 (interactive
498 (if current-prefix-arg
499 (list original-page-delimiter "^\f")
500 (list (read-string "Set page-delimiter to regexp: " page-delimiter)
501 nil)))
502 (make-local-variable 'original-page-delimiter)
503 (make-local-variable 'page-delimiter)
504 (setq original-page-delimiter
505 (or original-page-delimiter page-delimiter))
506 (if (not reset-p)
507 (setq page-delimiter regexp)
508 (setq page-delimiter original-page-delimiter))
509 (if (interactive-p)
510 (message "The value of `page-delimiter' is now: %s" page-delimiter)))
513 ;;; Pages directory main definitions
515 (defun pages-directory
516 (pages-list-all-headers-p count-lines-p &optional regexp)
517 "Display a directory of the page headers in a temporary buffer.
518 A header is the first non-blank line after the page-delimiter.
519 \\[pages-directory-mode]
520 You may move point to one of the lines in the temporary buffer,
521 then use \\<pages-directory-goto> to go to the same line in the pages buffer.
523 In interactive use:
525 1. With no prefix arg, display all headers.
527 2. With prefix arg, display the headers of only those pages that
528 contain matches to a regular expression for which you are
529 prompted.
531 3. With numeric prefix arg, for every page, print the number of
532 lines within each page.
534 4. With negative numeric prefix arg, for only those pages that
535 match a regular expression, print the number of lines within
536 each page.
538 When called from a program, non-nil first arg means list all headers;
539 non-nil second arg means print numbers of lines in each page; if first
540 arg is nil, optional third arg is regular expression.
542 If the buffer is narrowed, the `pages-directory' command creates a
543 directory for only the accessible portion of the buffer."
545 (interactive
546 (cond ((not current-prefix-arg)
547 (list t nil nil))
548 ((listp current-prefix-arg)
549 (list nil
551 (read-string
552 (format "Select according to `%s' (end with RET): "
553 (or pages-directory-previous-regexp "regexp")))))
554 ((> (prefix-numeric-value current-prefix-arg) 0)
555 (list t t nil))
556 ((< (prefix-numeric-value current-prefix-arg) 0)
557 (list nil
559 (read-string
560 (format "Select according to `%s' (end with RET): "
561 (or pages-directory-previous-regexp "regexp")))))))
563 (if (equal regexp "")
564 (setq regexp pages-directory-previous-regexp)
565 (setq pages-directory-previous-regexp regexp))
567 (if (interactive-p)
568 (message "Creating directory for: %s "
569 (buffer-name)))
571 (let ((target-buffer (current-buffer))
572 (pages-directory-buffer
573 (concat pages-directory-prefix " " (buffer-name)))
574 (linenum 1)
575 (pages-buffer-original-position (point))
576 (pages-buffer-original-page 0))
578 ;; `with-output-to-temp-buffer' binds the value of the variable
579 ;; `standard-output' to the buffer named as its first argument,
580 ;; but does not switch to that buffer.
581 (with-output-to-temp-buffer pages-directory-buffer
582 (save-excursion
583 (set-buffer standard-output)
584 (pages-directory-mode)
585 (insert
586 "==== Pages Directory: use `C-c C-c' to go to page under cursor. ====" ?\n)
587 (setq pages-buffer target-buffer)
588 (setq pages-pos-list nil))
590 (if pages-list-all-headers-p
592 ;; 1. If no prefix argument, list all headers
593 (save-excursion
594 (goto-char (point-min))
596 ;; (a) Point is at beginning of buffer; but the first
597 ;; page may not begin with a page-delimiter
598 (save-restriction
599 ;; If page delimiter is at beginning of buffer, skip it
600 (if (and (save-excursion
601 (re-search-forward page-delimiter nil t))
602 (= 1 (match-beginning 0)))
603 (goto-char (match-end 0)))
604 (narrow-to-page)
605 (pages-copy-header-and-position count-lines-p))
607 ;; (b) Search within pages buffer for next page-delimiter
608 (while (re-search-forward page-delimiter nil t)
609 (pages-copy-header-and-position count-lines-p)))
611 ;; 2. Else list headers whose pages match regexp.
612 (save-excursion
613 ;; REMOVED save-restriction AND widen FROM HERE
614 (goto-char (point-min))
616 ;; (a) Handle first page
617 (save-restriction
618 (narrow-to-page)
619 ;; search for selection regexp
620 (if (save-excursion (re-search-forward regexp nil t))
621 (pages-copy-header-and-position count-lines-p)))
623 ;; (b) Search for next page-delimiter
624 (while (re-search-forward page-delimiter nil t)
625 (save-restriction
626 (narrow-to-page)
627 ;; search for selection regexp
628 (if (save-excursion (re-search-forward regexp nil t))
629 (pages-copy-header-and-position count-lines-p)
630 )))))
632 (set-buffer standard-output)
633 ;; Put positions in increasing order to go with buffer.
634 (setq pages-pos-list (nreverse pages-pos-list))
635 (if (interactive-p)
636 (message "%d matching lines in: %s"
637 (length pages-pos-list) (buffer-name target-buffer))))
638 (pop-to-buffer pages-directory-buffer)
639 (sit-for 0) ; otherwise forward-line fails if N > window height.
640 (forward-line (if (= 0 pages-buffer-original-page)
642 pages-buffer-original-page))))
644 (defun pages-copy-header-and-position (count-lines-p)
645 "Copy page header and its position to the Pages Directory.
646 Only arg non-nil, count lines in page and insert before header.
647 Used by `pages-directory' function."
649 (let (position line-count)
651 (if count-lines-p
652 (save-excursion
653 (save-restriction
654 (narrow-to-page)
655 (setq line-count (count-lines (point-min) (point-max))))))
657 ;; Keep track of page for later cursor positioning
658 (if (<= (point) pages-buffer-original-position)
659 (setq pages-buffer-original-page
660 (1+ pages-buffer-original-page)))
662 (save-excursion
663 ;; go to first non-blank char after the page-delimiter
664 (skip-chars-forward " \t\n")
665 ;; set the marker here; this the place to which the
666 ;; `pages-directory-goto' command will go
667 (setq position (make-marker))
668 (set-marker position (point))
669 (let ((start (point))
670 (end (save-excursion (end-of-line) (point)))
671 inserted-at)
672 ;; change to directory buffer
673 (set-buffer standard-output)
674 ;; record page position
675 (setq pages-pos-list (cons position pages-pos-list))
676 ;; insert page header
677 (setq inserted-at (point))
678 (insert-buffer-substring target-buffer start end)
679 (put-text-property inserted-at (point)
680 'mouse-face 'highlight)
681 (put-text-property inserted-at (point) 'rear-nonsticky 'highlight))
683 (if count-lines-p
684 (save-excursion
685 (beginning-of-line)
686 (insert (format "%3d: " line-count))))
688 (terpri))
689 (end-of-line 1)))
691 (defun pages-directory-mode ()
692 "Mode for handling the pages-directory buffer.
694 Move point to one of the lines in this buffer, then use \\[pages-directory-goto] to go
695 to the same line in the pages buffer."
697 (kill-all-local-variables)
698 (use-local-map pages-directory-map)
699 (setq major-mode 'pages-directory-mode)
700 (setq mode-name "Pages-Directory")
701 (make-local-variable 'pages-buffer)
702 (make-local-variable 'pages-pos-list)
703 (make-local-variable 'pages-directory-buffer-narrowing-p))
705 (defun pages-directory-goto ()
706 "Go to the corresponding line in the pages buffer."
708 ;;; This function is mostly a copy of `occur-mode-goto-occurrence'
710 (interactive)
711 (if (or (not pages-buffer)
712 (not (buffer-name pages-buffer)))
713 (progn
714 (setq pages-buffer nil
715 pages-pos-list nil)
716 (error "Buffer in which pages were found is deleted.")))
717 (beginning-of-line)
718 (let* ((pages-number (1- (count-lines (point-min) (point))))
719 (pos (nth pages-number pages-pos-list))
720 (end-of-directory-p (eobp))
721 (narrowing-p pages-directory-buffer-narrowing-p))
722 (pop-to-buffer pages-buffer)
723 (widen)
724 (if end-of-directory-p
725 (goto-char (point-max))
726 (goto-char (marker-position pos)))
727 (if narrowing-p (narrow-to-page))))
729 (defun pages-directory-goto-with-mouse (event)
730 "Go to the corresponding line under the mouse pointer in the pages buffer."
731 (interactive "e")
732 (save-excursion
733 (set-buffer (window-buffer (posn-window (event-end event))))
734 (save-excursion
735 (goto-char (posn-point (event-end event)))
736 (pages-directory-goto))))
738 ;;; The `pages-directory-for-addresses' function and ancillary code
740 (defun pages-directory-for-addresses (&optional filename)
741 "Find addresses file and display its directory.
742 By default, create and display directory of `pages-addresses-file-name'.
743 Optional argument is FILENAME. In interactive use, with prefix
744 argument, prompt for file name and provide completion.
746 Move point to one of the lines in the displayed directory,
747 then use \\[pages-directory-goto] to go to the same line
748 in the addresses buffer.
750 If pages-directory-for-addresses-goto-narrowing-p is non-nil,
751 `pages-directory-goto' narrows addresses buffer to entry.
753 If pages-directory-for-addresses-buffer-keep-windows-p is nil,
754 this command deletes other windows when it displays the addresses
755 directory."
757 (interactive
758 (list (if current-prefix-arg
759 (read-file-name "Filename: " pages-addresses-file-name))))
761 (if (interactive-p)
762 (message "Creating directory for: %s "
763 (or filename pages-addresses-file-name)))
764 (if (file-exists-p (or filename pages-addresses-file-name))
765 (progn
766 (set-buffer
767 (find-file-noselect
768 (expand-file-name
769 (or filename pages-addresses-file-name))))
770 (widen)
771 (pages-directory t nil nil)
772 (pages-directory-address-mode)
773 (setq pages-directory-buffer-narrowing-p
774 pages-directory-for-addresses-goto-narrowing-p)
775 (or pages-directory-for-addresses-buffer-keep-windows-p
776 (delete-other-windows))
777 (save-excursion
778 (goto-char (point-min))
779 (delete-region (point) (save-excursion (end-of-line) (point)))
780 (insert
781 "=== Address List Directory: use `C-c C-c' to go to page under cursor. ===")
782 (set-buffer-modified-p nil)
784 (error "No addresses file found!")))
786 (defun pages-directory-address-mode ()
787 "Mode for handling the Addresses Directory buffer.
789 Move point to one of the lines in this buffer,
790 then use \\[pages-directory-goto] to go
791 to the same line in the pages buffer."
793 (use-local-map pages-directory-map)
794 (setq major-mode 'pages-directory-address-mode)
795 (setq mode-name "Addresses Directory")
796 (make-local-variable 'pages-buffer)
797 (make-local-variable 'pages-pos-list)
798 (make-local-variable 'pages-directory-buffer-narrowing-p))
801 ;;; Place `provide' at end of file.
802 (provide 'page-ext)
804 ;;;;;;;;;;;;;;;; end of page-ext.el ;;;;;;;;;;;;;;;;