1 This is ../info/xemacs.info, produced by makeinfo version 4.0 from
4 INFO-DIR-SECTION XEmacs Editor
6 * XEmacs: (xemacs). XEmacs Editor.
9 This file documents the XEmacs editor.
11 Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C)
12 1991, 1992, 1993, 1994 Lucid, Inc. Copyright (C) 1993, 1994 Sun
13 Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation.
15 Permission is granted to make and distribute verbatim copies of this
16 manual provided the copyright notice and this permission notice are
17 preserved on all copies.
19 Permission is granted to copy and distribute modified versions of
20 this manual under the conditions for verbatim copying, provided also
21 that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
22 General Public License" are included exactly as in the original, and
23 provided that the entire resulting derived work is distributed under the
24 terms of a permission notice identical to this one.
26 Permission is granted to copy and distribute translations of this
27 manual into another language, under the above conditions for modified
28 versions, except that the sections entitled "The GNU Manifesto",
29 "Distribution" and "GNU General Public License" may be included in a
30 translation approved by the author instead of in the original English.
33 File: xemacs.info, Node: Additional Mouse Operations, Next: Killing, Prev: Mouse Selection, Up: Top
35 Additional Mouse Operations
36 ===========================
38 XEmacs also provides the following mouse functions. Most of these
39 are not bound to mouse gestures by default, but they are provided for
40 your customization pleasure. For example, if you wanted `shift-left'
41 (that is, holding down the <Shift> key and clicking the left mouse
42 button) to delete the character at which you are pointing, then you
45 (global-set-key '(shift button1) 'mouse-del-char)
48 Delete the character pointed to by the mouse.
51 Delete the Emacs window that the mouse is on.
53 `mouse-keep-one-window'
54 Select the Emacs window that the mouse is on, then delete all other
55 windows on this frame.
58 Kill the line pointed to by the mouse.
61 Print the length of the line indicated by the pointer.
64 Scroll point to the mouse position.
67 Select the Emacs window the mouse is on.
69 `mouse-select-and-split'
70 Select the Emacs window mouse is on, then split it vertically in
74 Select the Emacs window the mouse is on and set the mark at the
75 mouse position. Display the cursor at that position for a second.
78 Select the Emacs window that the mouse is on and move point to the
82 Make a selection with the mouse. This is the default binding of
83 the left mouse button (<button1>).
86 Extend the existing selection. This is the default binding of
89 `mouse-track-and-copy-to-cutbuffer'
90 Make a selection like `mouse-track', but also copy it to the cut
93 `mouse-track-delete-and-insert'
94 Make a selection with the mouse and insert it at point. This is
95 the default binding of <control-shift-button1>.
98 Make a selection with the mouse and insert it at point. This is
99 the default binding of <control-button1>.
101 `mouse-window-to-region'
102 Narrow a window to the region between the cursor and the mouse
105 The `M-x mouse-track' command should be bound to a mouse button. If
106 you click-and-drag, the selection is set to the region between the
107 point of the initial click and the point at which you release the
108 button. These positions do not need to be ordered.
110 If you click-and-release without moving the mouse, the point is
111 moved, and the selection is disowned (there will be no selection
112 owner.) The mark will be set to the previous position of point.
114 If you double-click, the selection will extend by symbols instead of
115 by characters. If you triple-click, the selection will extend by lines.
117 If you drag the mouse off the top or bottom of the window, you can
118 select pieces of text that are larger than the visible part of the
119 buffer; the buffer will scroll as necessary.
121 The selected text becomes the current X selection, and is also
122 copied to the top of the kill ring. Point will be left at the position
123 at which you released the button and the mark will be left at the
124 initial click position. Bind a mouse click to
125 `mouse-track-and-copy-to-cutbuffer' to copy selections to the cut
126 buffer. (See also the `mouse-track-adjust' command, on
129 The `M-x mouse-track-adjust' command should be bound to a mouse
130 button. The selection will be enlarged or shrunk so that the point of
131 the mouse click is one of its endpoints. This is only meaningful after
132 the `mouse-track' command (<button1>) has been executed.
134 The `M-x mouse-track-delete-and-insert' command is exactly the same
135 as the `mouse-track' command on <button1>, except that point is not
136 moved; the selected text is immediately inserted after being selected;
137 and the text of the selection is deleted.
139 The `M-x mouse-track-insert' command is exactly the same as the
140 `mouse-track' command on <button1>, except that point is not moved; the
141 selected text is immediately inserted after being selected; and the
142 selection is immediately disowned afterwards.
145 File: xemacs.info, Node: Killing, Next: Yanking, Prev: Additional Mouse Operations, Up: Top
150 Most commands that erase text from the buffer save it. You can get
151 the text back if you change your mind, or you can move or copy it to
152 other parts of the buffer. Commands which erase text and save it in the
153 kill ring are known as "kill" commands. Some other commands erase text
154 but do not save it; they are known as "delete" commands. (This
155 distinction is made only for erasing text in the buffer.)
157 The commands' names and individual descriptions use the words `kill'
158 and `delete' to indicate what they do. If you perform a kill or delete
159 command by mistake, use the `C-x u' (`undo') command to undo it (*note
160 Undo::). The delete commands include `C-d' (`delete-char') and <DEL>
161 (`delete-backward-char'), which delete only one character at a time,
162 and those commands that delete only spaces or newlines. Commands that
163 can destroy significant amounts of nontrivial data usually kill.
169 Delete next character (`delete-char').
172 Delete previous character (`delete-backward-char').
175 Delete spaces and tabs around point (`delete-horizontal-space').
178 Delete spaces and tabs around point, leaving one space
182 Delete blank lines around the current line (`delete-blank-lines').
185 Join two lines by deleting the intervening newline, and any
186 indentation following it (`delete-indentation').
188 The most basic delete commands are `C-d' (`delete-char') and <DEL>
189 (`delete-backward-char'). `C-d' deletes the character after point, the
190 one the cursor is "on top of". Point doesn't move. <DEL> deletes the
191 character before the cursor, and moves point back. You can delete
192 newlines like any other characters in the buffer; deleting a newline
193 joins two lines. Actually, `C-d' and <DEL> aren't always delete
194 commands; if you give them an argument, they kill instead, since they
195 can erase more than one character this way.
197 The other delete commands delete only formatting characters: spaces,
198 tabs and newlines. `M-\' (`delete-horizontal-space') deletes all
199 spaces and tab characters before and after point. `M-<SPC>'
200 (`just-one-space') does the same but leaves a single space after point,
201 regardless of the number of spaces that existed previously (even zero).
203 `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
204 current line. If the current line is blank, it deletes all blank lines
205 preceding the current line as well as leaving one blank line, the
206 current line. `M-^' (`delete-indentation') joins the current line and
207 the previous line, or, if given an argument, joins the current line and
208 the next line by deleting a newline and all surrounding spaces, possibly
209 leaving a single space. *Note M-^: Indentation.
215 Kill rest of line or one or more lines (`kill-line').
217 The simplest kill command is `C-k'. If given at the beginning of a
218 line, it kills all the text on the line, leaving the line blank. If
219 given on a blank line, the blank line disappears. As a consequence, a
220 line disappears completely if you go to the front of a non-blank line
221 and type `C-k' twice.
223 More generally, `C-k' kills from point up to the end of the line,
224 unless it is at the end of a line. In that case, it kills the newline
225 following the line, thus merging the next line into the current one.
226 Emacs ignores invisible spaces and tabs at the end of the line when
227 deciding which case applies: if point appears to be at the end of the
228 line, you can be sure the newline will be killed.
230 If you give `C-k' a positive argument, it kills that many lines and
231 the newlines that follow them (however, text on the current line before
232 point is not killed). With a negative argument, `C-k' kills back to a
233 number of line beginnings. An argument of -2 means kill back to the
234 second line beginning. If point is at the beginning of a line, that
235 line beginning doesn't count, so `C-u - 2 C-k' with point at the front
236 of a line kills the two previous lines.
238 `C-k' with an argument of zero kills all the text before point on the
245 Kill region (from point to the mark) (`kill-region'). *Note
249 Kill word (`kill-word').
252 Kill word backwards (`backward-kill-word').
255 Kill back to beginning of sentence (`backward-kill-sentence').
259 Kill to end of sentence (`kill-sentence').
262 Kill sexp (`kill-sexp'). *Note Lists::.
265 Kill up to next occurrence of CHAR (`zap-to-char').
267 `C-w' (`kill-region') is a very general kill command; it kills
268 everything between point and the mark. You can use this command to kill
269 any contiguous sequence of characters by first setting the mark at one
270 end of a sequence of characters, then going to the other end and typing
273 A convenient way of killing is combined with searching: `M-z'
274 (`zap-to-char') reads a character and kills from point up to (but not
275 including) the next occurrence of that character in the buffer. If
276 there is no next occurrence, killing goes to the end of the buffer. A
277 numeric argument acts as a repeat count. A negative argument means to
278 search backward and kill text before point.
280 Other syntactic units can be killed: words, with `M-<DEL>' and `M-d'
281 (*note Words::); sexps, with `C-M-k' (*note Lists::); and sentences,
282 with `C-x <DEL>' and `M-k' (*note Sentences::).
285 File: xemacs.info, Node: Yanking, Next: Using X Selections, Prev: Killing, Up: Top
290 "Yanking" means getting back text which was killed. Some systems
291 call this "pasting". The usual way to move or copy text is to kill it
292 and then yank it one or more times.
295 Yank last killed text (`yank').
298 Replace re-inserted killed text with the previously killed text
302 Save region as last killed text without actually killing it
303 (`copy-region-as-kill').
306 Append next kill to last batch of killed text (`append-next-kill').
310 * Kill Ring:: Where killed text is stored. Basic yanking.
311 * Appending Kills:: Several kills in a row all yank together.
312 * Earlier Kills:: Yanking something killed some time ago.
315 File: xemacs.info, Node: Kill Ring, Next: Appending Kills, Prev: Yanking, Up: Yanking
320 All killed text is recorded in the "kill ring", a list of blocks of
321 text that have been killed. There is only one kill ring, used in all
322 buffers, so you can kill text in one buffer and yank it in another
323 buffer. This is the usual way to move text from one file to another.
324 (*Note Accumulating Text::, for some other ways.)
326 If you have two separate Emacs processes, you cannot use the kill
327 ring to move text. If you are using XEmacs under X, however, you can
328 use the X selection mechanism to move text from one to another.
330 If you are using XEmacs under X and have one Emacs process with
331 multiple frames, they do share the same kill ring. You can kill or
332 copy text in one Emacs frame, then yank it in the other frame belonging
335 The command `C-y' (`yank') reinserts the text of the most recent
336 kill. It leaves the cursor at the end of the text and sets the mark at
337 the beginning of the text. *Note Mark::.
339 `C-u C-y' yanks the text, leaves the cursor in front of the text,
340 and sets the mark after it, if the argument is with just a `C-u'. Any
341 other argument, including `C-u' and digits, has different results,
342 described below, under "Yanking Earlier Kills".
344 To copy a block of text, you can also use `M-w'
345 (`copy-region-as-kill'), which copies the region into the kill ring
346 without removing it from the buffer. `M-w' is similar to `C-w' followed
347 by `C-y' but does not mark the buffer as "modified" and does not
348 actually cut anything.
351 File: xemacs.info, Node: Appending Kills, Next: Earlier Kills, Prev: Kill Ring, Up: Yanking
356 Normally, each kill command pushes a new block onto the kill ring.
357 However, two or more kill commands in a row combine their text into a
358 single entry, so that a single `C-y' yanks it all back. This means you
359 don't have to kill all the text you want to yank in one command; you
360 can kill line after line, or word after word, until you have killed what
361 you want, then get it all back at once using `C-y'. (Thus we join
362 television in leading people to kill thoughtlessly.)
364 Commands that kill forward from point add onto the end of the
365 previous killed text. Commands that kill backward from point add onto
366 the beginning. This way, any sequence of mixed forward and backward
367 kill commands puts all the killed text into one entry without
368 rearrangement. Numeric arguments do not break the sequence of
369 appending kills. For example, suppose the buffer contains:
373 and here is the third.
375 with point at the beginning of the second line. If you type `C-k C-u 2
376 M-<DEL> C-k', the first `C-k' kills the text `line of sample text',
377 `C-u 2 M-<DEL>' kills `the first' with the newline that followed it,
378 and the second `C-k' kills the newline after the second line. The
379 result is that the buffer contains `This is and here is the third.' and
380 a single kill entry contains `the first<RET>line of sample
381 text<RET>'--all the killed text, in its original order.
383 If a kill command is separated from the last kill command by other
384 commands (not just numeric arguments), it starts a new entry on the kill
385 ring. To force a kill command to append, first type the command `C-M-w'
386 (`append-next-kill'). `C-M-w' tells the following command, if it is a
387 kill command, to append the text it kills to the last killed text,
388 instead of starting a new entry. With `C-M-w', you can kill several
389 separated pieces of text and accumulate them to be yanked back in one
393 File: xemacs.info, Node: Earlier Kills, Prev: Appending Kills, Up: Yanking
395 Yanking Earlier Kills
396 ---------------------
398 To recover killed text that is no longer the most recent kill, you
399 need the `Meta-y' (`yank-pop') command. You can use `M-y' only after a
400 `C-y' or another `M-y'. It takes the text previously yanked and
401 replaces it with the text from an earlier kill. To recover the text of
402 the next-to-the-last kill, first use `C-y' to recover the last kill,
403 then `M-y' to replace it with the previous kill.
405 You can think in terms of a "last yank" pointer which points at an
406 item in the kill ring. Each time you kill, the "last yank" pointer
407 moves to the new item at the front of the ring. `C-y' yanks the item
408 which the "last yank" pointer points to. `M-y' moves the "last yank"
409 pointer to a different item, and the text in the buffer changes to
410 match. Enough `M-y' commands can move the pointer to any item in the
411 ring, so you can get any item into the buffer. Eventually the pointer
412 reaches the end of the ring; the next `M-y' moves it to the first item
415 Yanking moves the "last yank" pointer around the ring, but does not
416 change the order of the entries in the ring, which always runs from the
417 most recent kill at the front to the oldest one still remembered.
419 Use `M-y' with a numeric argument to advance the "last yank" pointer
420 by the specified number of items. A negative argument moves the
421 pointer toward the front of the ring; from the front of the ring, it
422 moves to the last entry and starts moving forward from there.
424 Once the text you are looking for is brought into the buffer, you can
425 stop doing `M-y' commands and the text will stay there. Since the text
426 is just a copy of the kill ring item, editing it in the buffer does not
427 change what's in the ring. As long you don't kill additional text, the
428 "last yank" pointer remains at the same place in the kill ring:
429 repeating `C-y' will yank another copy of the same old kill.
431 If you know how many `M-y' commands it would take to find the text
432 you want, you can yank that text in one step using `C-y' with a numeric
433 argument. `C-y' with an argument greater than one restores the text
434 the specified number of entries back in the kill ring. Thus, `C-u 2
435 C-y' gets the next to the last block of killed text. It is equivalent
436 to `C-y M-y'. `C-y' with a numeric argument starts counting from the
437 "last yank" pointer, and sets the "last yank" pointer to the entry that
440 The variable `kill-ring-max' controls the length of the kill ring;
441 no more than that many blocks of killed text are saved.
444 File: xemacs.info, Node: Using X Selections, Next: Accumulating Text, Prev: Yanking, Up: Top
449 In the X window system, mouse selections provide a simple mechanism
450 for text transfer between different applications. In a typical X
451 application, you can select text by pressing the left mouse button and
452 dragging the cursor over the text you want to copy. The text becomes
453 the primary X selection and is highlighted. The highlighted region is
454 also the Emacs selected region.
456 * Since the region is the primary X selection, you can go to a
457 different X application and click the middle mouse button: the
458 text that you selected in the previous application is pasted into
459 the current application.
461 * Since the region is the Emacs selected region, you can use all
462 region commands (`C-w, M-w' etc.) as well as the options of the
463 Edit menu to manipulate the selected text.
467 * X Clipboard Selection:: Pasting to the X clipboard.
468 * X Selection Commands:: Other operations on the selection.
469 * X Cut Buffers:: X cut buffers are available for compatibility.
470 * Active Regions:: Using zmacs-style highlighting of the
474 File: xemacs.info, Node: X Clipboard Selection, Next: X Selection Commands, Prev: Using X Selections, Up: Using X Selections
476 The Clipboard Selection
477 -----------------------
479 There are other kinds of X selections besides the Primary selection;
480 one common one is the Clipboard selection. Some applications prefer to
481 transfer data using this selection in preference to the Primary. One
482 can transfer text from the Primary selection to the Clipboard
483 selection with the Copy command under the Edit menu in the menubar.
485 Usually, the clipboard selection is not visible. However, if you
486 run the `xclipboard' application, the text most recently copied to the
487 clipboard (with the Copy command) is displayed in a window. Any time
488 new text is thus copied, the `xclipboard' application makes a copy of
489 it and displays it in its window. The value of the clipboard can
490 survive the lifetime of the running Emacs process. The `xclipboard'
491 man page provides more details.
493 Warning: If you use the `xclipboard' application, remember that it
494 maintains a list of all things that have been pasted to the clipboard
495 (that is, copied with the Copy command). If you don't manually delete
496 elements from this list by clicking on the Delete button in the
497 `xclipboard' window, the clipboard will eventually consume a lot of
500 In summary, some X applications (such as `xterm') allow one to paste
501 text in them from XEmacs in the following way:
503 * Drag out a region of text in Emacs with the left mouse button,
504 making that text be the Primary selection.
506 * Click the middle button in the other application, pasting the
509 With some other applications (notably, the OpenWindows and Motif
510 tools) you must use this method instead:
512 * Drag out a region of text in Emacs with the left mouse button,
513 making that text be the Primary selection.
515 * Copy the selected text to the Clipboard selection by selecting the
516 Copy menu item from the Edit menu, or by hitting the Copy key on
519 * Paste the text in the other application by selecting Paste from its
520 menu, or by hitting the Paste key on your keyboard.
523 File: xemacs.info, Node: X Selection Commands, Next: X Cut Buffers, Prev: X Clipboard Selection, Up: Using X Selections
525 Miscellaneous X Selection Commands
526 ----------------------------------
528 `M-x x-copy-primary-selection'
529 Copy the primary selection to both the kill ring and the Clipboard.
531 `M-x x-insert-selection'
532 Insert the current selection into the buffer at point.
534 `M-x x-delete-primary-selection'
535 Deletes the text in the primary selection without copying it to
536 the kill ring or the Clipboard.
538 `M-x x-kill-primary-selection'
539 Deletes the text in the primary selection and copies it to both
540 the kill ring and the Clipboard.
543 Kill the text between point and the mouse and copy it to the
544 clipboard and to the cut buffer.
546 `M-x x-own-secondary-selection'
547 Make a secondary X selection of the given argument.
549 `M-x x-own-selection'
550 Make a primary X selection of the given argument.
552 `M-x x-set-point-and-insert-selection'
553 Set point where clicked and insert the primary selection or the
557 File: xemacs.info, Node: X Cut Buffers, Next: Active Regions, Prev: X Selection Commands, Up: Using X Selections
562 X cut buffers are a different, older way of transferring text between
563 applications. XEmacs supports cut buffers for compatibility with older
564 programs, even though selections are now the preferred way of
567 X has a concept of applications "owning" selections. When you select
568 text by clicking and dragging inside an application, the application
569 tells the X server that it owns the selection. When another
570 application asks the X server for the value of the selection, the X
571 server requests the information from the owner. When you use
572 selections, the selection data is not actually transferred unless
573 someone wants it; the act of making a selection doesn't transfer data.
574 Cut buffers are different: when you "own" a cut buffer, the data is
575 actually transferred to the X server immediately, and survives the
576 lifetime of the application.
578 Any time a region of text becomes the primary selection in Emacs,
579 Emacs also copies that text to the cut buffer. This makes it possible
580 to copy text from an XEmacs buffer and paste it into an older,
581 non-selection-based application (such as Emacs 18).
583 Note: Older versions of Emacs could not access the X selections, only
587 File: xemacs.info, Node: Active Regions, Prev: X Cut Buffers, Up: Using X Selections
592 By default, both the text you select in an Emacs buffer using the
593 click-and-drag mechanism and text you select by setting point and the
594 mark is highlighted. You can use Emacs region commands as well as the
595 Cut and Copy commands on the highlighted region you selected with the
598 If you prefer, you can make a distinction between text selected with
599 the mouse and text selected with point and the mark by setting the
600 variable `zmacs-regions' to `nil'. In that case:
602 * The text selected with the mouse becomes both the X selection and
603 the Emacs selected region. You can use menu-bar commands as well
604 as Emacs region commands on it.
606 * The text selected with point and the mark is not highlighted. You
607 can only use Emacs region commands on it, not the menu-bar items.
609 Active regions originally come from Zmacs, the Lisp Machine editor.
610 The idea behind them is that commands can only operate on a region when
611 the region is in an "active" state. Put simply, you can only operate on
612 a region that is highlighted.
614 The variable `zmacs-regions' checks whether LISPM-style active
615 regions should be used. This means that commands that operate on the
616 region (the area between point and the mark) only work while the region
617 is in the active state, which is indicated by highlighting. Most
618 commands causes the region to not be in the active state; for example,
619 `C-w' only works immediately after activating the region.
622 * Commands that operate on the region only work if the region is
625 * Only a very small set of commands causes the region to become
626 active-- those commands whose semantics are to mark an area, such
629 * The region is deactivated after each command that is executed,
630 except that motion commands do not change whether the region is
633 `set-mark-command' (`C-SPC') pushes a mark and activates the region.
634 Moving the cursor with normal motion commands (`C-n', `C-p', etc.)
635 will cause the region between point and the recently-pushed mark to be
636 highlighted. It will remain highlighted until some non-motion command
639 `exchange-point-and-mark' (`C-x C-x') activates the region. So if
640 you mark a region and execute a command that operates on it, you can
641 reactivate the same region with `C-x C-x' (or perhaps `C-x C-x C-x
642 C-x') to operate on it again.
644 Generally, commands that push marks as a means of navigation, such as
645 `beginning-of-buffer' (`M-<') and `end-of-buffer' (`M->'), do not
646 activate the region. However, commands that push marks as a means of
647 marking an area of text, such as `mark-defun' (`M-C-h'), `mark-word'
648 (`M-@'), and `mark-whole-buffer' (`C-x h'), do activate the region.
650 When `zmacs-regions' is `t', there is no distinction between the
651 primary X selection and the active region selected by point and the
652 mark. To see this, set the mark (<C-SPC>) and move the cursor with any
653 cursor-motion command: the region between point and mark is
654 highlighted, and you can watch it grow and shrink as you move the
657 Any other commands besides cursor-motion commands (such as inserting
658 or deleting text) will cause the region to no longer be active; it will
659 no longer be highlighted, and will no longer be the primary selection.
660 Region can be explicitly deactivated with `C-g'.
662 Commands that require a region (such as `C-w') signal an error if
663 the region is not active. Certain commands cause the region to be in
664 its active state. The most common ones are `push-mark' (<C-SPC>) and
665 `exchange-point-and-mark' (`C-x C-x').
667 When `zmacs-regions' is `t', programs can be non-intrusive on the
668 state of the region by setting the variable `zmacs-region-stays' to a
669 non-`nil' value. If you are writing a new Emacs command that is
670 conceptually a "motion" command and should not interfere with the
671 current highlightedness of the region, then you may set this variable.
672 It is reset to `nil' after each user command is executed.
674 When `zmacs-regions' is `t', programs can make the region between
675 point and mark go into the active (highlighted) state by using the
676 function `zmacs-activate-region'. Only a small number of commands
679 When `zmacs-regions' is `t', programs can deactivate the region
680 between point and the mark by using `zmacs-deactivate-region'. Note:
681 you should not have to call this function; the command loop calls it
685 File: xemacs.info, Node: Accumulating Text, Next: Rectangles, Prev: Using X Selections, Up: Top
690 Usually you copy or move text by killing it and yanking it, but
691 there are other ways that are useful for copying one block of text in
692 many places, or for copying many scattered blocks of text into one
695 If you like, you can accumulate blocks of text from scattered
696 locations either into a buffer or into a file. The relevant commands
697 are described here. You can also use Emacs registers for storing and
698 accumulating text. *Note Registers::.
700 `M-x append-to-buffer'
701 Append region to contents of specified buffer (`append-to-buffer').
703 `M-x prepend-to-buffer'
704 Prepend region to contents of specified buffer.
707 Copy region into specified buffer, deleting that buffer's old
711 Insert contents of specified buffer into current buffer at point.
714 Append region to the end of the contents of specified file.
716 To accumulate text into a buffer, use the command `M-x
717 append-to-buffer', which inserts a copy of the region into the buffer
718 BUFFERNAME, at the location of point in that buffer. If there is no
719 buffer with the given name, one is created.
721 If you append text to a buffer that has been used for editing, the
722 copied text goes to the place where point is. Point in that buffer is
723 left at the end of the copied text, so successive uses of
724 `append-to-buffer' accumulate the text in the specified buffer in the
725 same order as they were copied. Strictly speaking, this command does
726 not always append to the text already in the buffer; but if this command
727 is the only command used to alter a buffer, it does always append to the
728 existing text because point is always at the end.
730 `M-x prepend-to-buffer' is similar to `append-to-buffer', but point
731 in the other buffer is left before the copied text, so successive
732 prependings add text in reverse order. `M-x copy-to-buffer' is
733 similar, except that any existing text in the other buffer is deleted,
734 so the buffer is left containing just the text newly copied into it.
736 You can retrieve the accumulated text from that buffer with `M-x
737 insert-buffer', which takes BUFFERNAME as an argument. It inserts a
738 copy of the text in buffer BUFFERNAME into the selected buffer. You
739 could alternatively select the other buffer for editing, perhaps moving
740 text from it by killing or with `append-to-buffer'. *Note Buffers::,
741 for background information on buffers.
743 Instead of accumulating text within Emacs in a buffer, you can append
744 text directly into a file with `M-x append-to-file', which takes
745 FILE-NAME as an argument. It adds the text of the region to the end of
746 the specified file. The file is changed immediately on disk. This
747 command is normally used with files that are not being visited in
748 Emacs. Using it on a file that Emacs is visiting can produce confusing
749 results, because the file's text inside Emacs does not change while the
753 File: xemacs.info, Node: Rectangles, Next: Registers, Prev: Accumulating Text, Up: Top
758 The rectangle commands affect rectangular areas of text: all
759 characters between a certain pair of columns, in a certain range of
760 lines. Commands are provided to kill rectangles, yank killed
761 rectangles, clear them out, or delete them. Rectangle commands are
762 useful with text in multicolumnar formats, like code with comments at
763 the right, or for changing text into or out of such formats.
765 To specify the rectangle a command should work on, put the mark at
766 one corner and point at the opposite corner. The specified rectangle is
767 called the "region-rectangle" because it is controlled about the same
768 way the region is controlled. Remember that a given combination of
769 point and mark values can be interpreted either as specifying a region
770 or as specifying a rectangle; it is up to the command that uses them to
771 choose the interpretation.
773 `M-x delete-rectangle'
774 Delete the text of the region-rectangle, moving any following text
775 on each line leftward to the left edge of the region-rectangle.
778 Similar, but also save the contents of the region-rectangle as the
779 "last killed rectangle".
782 Yank the last killed rectangle with its upper left corner at point.
785 Insert blank space to fill the space of the region-rectangle. The
786 previous contents of the region-rectangle are pushed rightward.
788 `M-x clear-rectangle'
789 Clear the region-rectangle by replacing its contents with spaces.
791 The rectangle operations fall into two classes: commands deleting and
792 moving rectangles, and commands for blank rectangles.
794 There are two ways to get rid of the text in a rectangle: you can
795 discard the text (delete it) or save it as the "last killed" rectangle.
796 The commands for these two ways are `M-x delete-rectangle' and `M-x
797 kill-rectangle'. In either case, the portion of each line that falls
798 inside the rectangle's boundaries is deleted, causing following text
799 (if any) on the line to move left.
801 Note that "killing" a rectangle is not killing in the usual sense;
802 the rectangle is not stored in the kill ring, but in a special place
803 that only records the most recently killed rectangle (that is, does not
804 append to a killed rectangle). Different yank commands have to be used
805 and only one rectangle is stored, because yanking a rectangle is quite
806 different from yanking linear text and yank-popping commands are
807 difficult to make sense of.
809 Inserting a rectangle is the opposite of deleting one. You specify
810 where to put the upper left corner by putting point there. The
811 rectangle's first line is inserted at point, the rectangle's second line
812 is inserted at a point one line vertically down, and so on. The number
813 of lines affected is determined by the height of the saved rectangle.
815 To insert the last killed rectangle, type `M-x yank-rectangle'.
816 This can be used to convert single-column lists into double-column
817 lists; kill the second half of the list as a rectangle and then yank it
818 beside the first line of the list.
820 There are two commands for working with blank rectangles: `M-x
821 clear-rectangle' erases existing text, and `M-x open-rectangle' inserts
822 a blank rectangle. Clearing a rectangle is equivalent to deleting it
823 and then inserting a blank rectangle of the same size.
825 Rectangles can also be copied into and out of registers. *Note
826 Rectangle Registers: RegRect.
829 File: xemacs.info, Node: Registers, Next: Display, Prev: Rectangles, Up: Top
834 XEmacs "registers" are places in which you can save text or
835 positions for later use. Once you save text or a rectangle in a
836 register, you can copy it into the buffer once or many times; a position
837 saved in a register is used by moving point to that position.
838 Rectangles can also be copied into and out of registers (*note
841 Each register has a name which is a single character. A register can
842 store a piece of text, a rectangle, a position, a window configuration,
843 or a file name, but only one thing at any given time. Whatever you
844 store in a register remains there until you store something else in that
845 register. To see what a register R contains, use `M-x view-register'.
847 `M-x view-register <RET> R'
848 Display a description of what register R contains.
850 `M-x view-register' reads a register name as an argument and then
851 displays the contents of the specified register.
855 * Position: RegPos. Saving positions in registers.
856 * Text: RegText. Saving text in registers.
857 * Rectangle: RegRect. Saving rectangles in registers.
858 * Configurations: RegConfig. Saving window configurations in registers.
859 * Files: RegFiles. File names in registers.
860 * Numbers: RegNumbers. Numbers in registers.
861 * Bookmarks:: Bookmarks are like registers, but persistent.
864 File: xemacs.info, Node: RegPos, Next: RegText, Prev: Registers, Up: Registers
866 Saving Positions in Registers
867 =============================
869 Saving a position records a place in a buffer so that you can move
870 back there later. Moving to a saved position switches to that buffer
871 and moves point to that place in it.
874 Save position of point in register R (`point-to-register').
877 Jump to the position saved in register R (`jump-to-register').
879 To save the current position of point in a register, choose a name R
880 and type `C-x r <SPC> R'. The register R retains the position thus
881 saved until you store something else in that register.
883 The command `C-x r j R' moves point to the position recorded in
884 register R. The register is not affected; it continues to record the
885 same location. You can jump to the same position using the same
886 register as often as you want.
888 If you use `C-x r j' to go to a saved position, but the buffer it
889 was saved from has been killed, `C-x r j' tries to create the buffer
890 again by visiting the same file. Of course, this works only for buffers
891 that were visiting files.
894 File: xemacs.info, Node: RegText, Next: RegRect, Prev: RegPos, Up: Registers
896 Saving Text in Registers
897 ========================
899 When you want to insert a copy of the same piece of text many times,
900 it can be impractical to use the kill ring, since each subsequent kill
901 moves the piece of text further down on the ring. It becomes hard to
902 keep track of the argument needed to retrieve the same text with `C-y'.
903 An alternative is to store the text in a register with `C-x r s'
904 (`copy-to-register') and then retrieve it with `C-x r i'
908 Copy region into register R (`copy-to-register').
912 Insert text contents of register R (`insert-register').
914 `C-x r s R' stores a copy of the text of the region into the
915 register named R. Given a numeric argument, `C-x r s R' deletes the
916 text from the buffer as well.
918 `C-x r i R' inserts the text from register R in the buffer. By
919 default it leaves point before the text and places the mark after it.
920 With a numeric argument (`C-u'), it puts point after the text and the
924 File: xemacs.info, Node: RegRect, Next: RegConfig, Prev: RegText, Up: Registers
926 Saving Rectangles in Registers
927 ==============================
929 A register can contain a rectangle instead of lines of text. The
930 rectangle is represented as a list of strings. *Note Rectangles::, for
931 basic information on rectangles and how to specify rectangles in a
935 Copy the region-rectangle into register R
936 (`copy-rectangle-to-register'). With a numeric argument, delete it
941 Insert the rectangle stored in register R (if it contains a
942 rectangle) (`insert-register').
944 The `C-x r i R' command inserts linear text if the register
945 contains that, or inserts a rectangle if the register contains one.
947 See also the command `sort-columns', which you can think of as
948 sorting a rectangle. *Note Sorting::.
951 File: xemacs.info, Node: RegConfig, Next: RegNumbers, Prev: RegRect, Up: Registers
953 Saving Window Configurations in Registers
954 =========================================
956 You can save the window configuration of the selected frame in a
957 register, or even the configuration of all windows in all frames, and
958 restore the configuration later.
961 Save the state of the selected frame's windows in register R
962 (`window-configuration-to-register').
964 `M-x frame-configuration-to-register <RET> R'
965 Save the state of all frames, including all their windows, in
966 register R (`frame-configuration-to-register').
968 Use `C-x r j R' to restore a window or frame configuration. This is
969 the same command used to restore a cursor position. When you restore a
970 frame configuration, any existing frames not included in the
971 configuration become invisible. If you wish to delete these frames
972 instead, use `C-u C-x r j R'.
975 File: xemacs.info, Node: RegNumbers, Next: RegFiles, Prev: RegConfig, Up: Registers
977 Keeping Numbers in Registers
978 ============================
980 There are commands to store a number in a register, to insert the
981 number in the buffer in decimal, and to increment it. These commands
982 can be useful in keyboard macros (*note Keyboard Macros::).
984 `C-u NUMBER C-x r n REG'
985 Store NUMBER into register REG (`number-to-register').
987 `C-u NUMBER C-x r + REG'
988 Increment the number in register REG by NUMBER
989 (`increment-register').
992 Insert the number from register REG into the buffer.
994 `C-x r g' is the same command used to insert any other sort of
995 register contents into the buffer.
998 File: xemacs.info, Node: RegFiles, Next: Bookmarks, Prev: RegNumbers, Up: Registers
1000 Keeping File Names in Registers
1001 ===============================
1003 If you visit certain file names frequently, you can visit them more
1004 conveniently if you put their names in registers. Here's the Lisp code
1005 used to put a file name in a register:
1007 (set-register ?R '(file . NAME))
1011 (set-register ?z '(file . "/usr/src/xemacs/src/ChangeLog"))
1013 puts the file name shown in register `z'.
1015 To visit the file whose name is in register R, type `C-x r j R'.
1016 (This is the same command used to jump to a position or restore a frame
1020 File: xemacs.info, Node: Bookmarks, Prev: RegFiles, Up: Registers
1025 "Bookmarks" are somewhat like registers in that they record
1026 positions you can jump to. Unlike registers, they have long names, and
1027 they persist automatically from one Emacs session to the next. The
1028 prototypical use of bookmarks is to record "where you were reading" in
1031 Note: bookmark.el is distributed in edit-utils package. You need to
1032 install that to use bookmark facility (*note Packages::).
1035 Set the bookmark for the visited file, at point.
1037 `C-x r m BOOKMARK <RET>'
1038 Set the bookmark named BOOKMARK at point (`bookmark-set').
1040 `C-x r b BOOKMARK <RET>'
1041 Jump to the bookmark named BOOKMARK (`bookmark-jump').
1044 List all bookmarks (`list-bookmarks').
1047 Save all the current bookmark values in the default bookmark file.
1049 The prototypical use for bookmarks is to record one current position
1050 in each of several files. So the command `C-x r m', which sets a
1051 bookmark, uses the visited file name as the default for the bookmark
1052 name. If you name each bookmark after the file it points to, then you
1053 can conveniently revisit any of those files with `C-x r b', and move to
1054 the position of the bookmark at the same time.
1056 To display a list of all your bookmarks in a separate buffer, type
1057 `C-x r l' (`list-bookmarks'). If you switch to that buffer, you can
1058 use it to edit your bookmark definitions or annotate the bookmarks.
1059 Type `C-h m' in that buffer for more information about its special
1062 When you kill XEmacs, XEmacs offers to save your bookmark values in
1063 your default bookmark file, `~/.emacs.bmk', if you have changed any
1064 bookmark values. You can also save the bookmarks at any time with the
1065 `M-x bookmark-save' command. The bookmark commands load your default
1066 bookmark file automatically. This saving and loading is how bookmarks
1067 persist from one XEmacs session to the next.
1069 If you set the variable `bookmark-save-flag' to 1, then each command
1070 that sets a bookmark will also save your bookmarks; this way, you don't
1071 lose any bookmark values even if XEmacs crashes. (The value, if a
1072 number, says how many bookmark modifications should go by between
1075 Bookmark position values are saved with surrounding context, so that
1076 `bookmark-jump' can find the proper position even if the file is
1077 modified slightly. The variable `bookmark-search-size' says how many
1078 characters of context to record, on each side of the bookmark's
1081 Here are some additional commands for working with bookmarks:
1083 `M-x bookmark-load <RET> FILENAME <RET>'
1084 Load a file named FILENAME that contains a list of bookmark
1085 values. You can use this command, as well as `bookmark-write', to
1086 work with other files of bookmark values in addition to your
1087 default bookmark file.
1089 `M-x bookmark-write <RET> FILENAME <RET>'
1090 Save all the current bookmark values in the file FILENAME.
1092 `M-x bookmark-delete <RET> BOOKMARK <RET>'
1093 Delete the bookmark named BOOKMARK.
1095 `M-x bookmark-insert-location <RET> BOOKMARK <RET>'
1096 Insert in the buffer the name of the file that bookmark BOOKMARK
1099 `M-x bookmark-insert <RET> BOOKMARK <RET>'
1100 Insert in the buffer the _contents_ of the file that bookmark
1104 File: xemacs.info, Node: Display, Next: Search, Prev: Registers, Up: Top
1106 Controlling the Display
1107 ***********************
1109 Since only part of a large buffer fits in the window, XEmacs tries
1110 to show the part that is likely to be interesting. The display control
1111 commands allow you to specify which part of the text you want to see.
1114 Clear frame and redisplay, scrolling the selected window to center
1115 point vertically within it (`recenter').
1120 Scroll forward (a windowful or a specified number of lines)
1121 (`scroll-up'). On most X keyboards, you can get this
1122 functionality using the key labelled `Page Down', which generates
1123 either `next' or `pgdn'.
1128 Scroll backward (`scroll-down'). On most X keyboards, you can get
1129 this functionality using the key labelled `Page Up', which
1130 generates either `prior' or `pgup'.
1133 Scroll so point is on line ARG (`recenter').
1138 Scroll text in current window to the left (`scroll-left').
1143 Scroll to the right (`scroll-right').
1146 Make deeply indented lines invisible (`set-selective-display').
1150 * Scrolling:: Moving text up and down in a window.
1151 * Horizontal Scrolling:: Moving text left and right in a window.
1152 * Selective Display:: Hiding lines with lots of indentation.
1153 * Display Vars:: Information on variables for customizing display.
1156 File: xemacs.info, Node: Scrolling, Next: Horizontal Scrolling, Prev: Display, Up: Display
1161 If a buffer contains text that is too large to fit entirely within
1162 the window that is displaying the buffer, XEmacs shows a contiguous
1163 section of the text. The section shown always contains point.
1165 "Scrolling" means moving text up or down in the window so that
1166 different parts of the text are visible. Scrolling forward means that
1167 text moves up, and new text appears at the bottom. Scrolling backward
1168 moves text down and new text appears at the top.
1170 Scrolling happens automatically if you move point past the bottom or
1171 top of the window. You can also explicitly request scrolling with the
1172 commands in this section.
1175 Clear frame and redisplay, scrolling the selected window to center
1176 point vertically within it (`recenter').
1181 Scroll forward (a windowful or a specified number of lines)
1187 Scroll backward (`scroll-down').
1190 Scroll so point is on line ARG (`recenter').
1192 The most basic scrolling command is `C-l' (`recenter') with no
1193 argument. It clears the entire frame and redisplays all windows. In
1194 addition, it scrolls the selected window so that point is halfway down
1195 from the top of the window.
1197 The scrolling commands `C-v' and `M-v' let you move all the text in
1198 the window up or down a few lines. `C-v' (`scroll-up') with an
1199 argument shows you that many more lines at the bottom of the window,
1200 moving the text and point up together as `C-l' might. `C-v' with a
1201 negative argument shows you more lines at the top of the window.
1202 `Meta-v' (`scroll-down') is like `C-v', but moves in the opposite
1205 To read the buffer a windowful at a time, use `C-v' with no
1206 argument. `C-v' takes the last two lines at the bottom of the window
1207 and puts them at the top, followed by nearly a whole windowful of lines
1208 not previously visible. Point moves to the new top of the window if it
1209 was in the text scrolled off the top. `M-v' with no argument moves
1210 backward with similar overlap. The number of lines of overlap across a
1211 `C-v' or `M-v' is controlled by the variable
1212 `next-screen-context-lines'; by default, it is two.
1214 Another way to scroll is using `C-l' with a numeric argument. `C-l'
1215 does not clear the frame when given an argument; it only scrolls the
1216 selected window. With a positive argument N, `C-l' repositions text to
1217 put point N lines down from the top. An argument of zero puts point on
1218 the very top line. Point does not move with respect to the text;
1219 rather, the text and point move rigidly on the frame. `C-l' with a
1220 negative argument puts point that many lines from the bottom of the
1221 window. For example, `C-u - 1 C-l' puts point on the bottom line, and
1222 `C-u - 5 C-l' puts it five lines from the bottom. Just `C-u' as
1223 argument, as in `C-u C-l', scrolls point to the center of the frame.
1225 Scrolling happens automatically if point has moved out of the visible
1226 portion of the text when it is time to display. Usually scrolling is
1227 done to put point vertically centered within the window. However, if
1228 the variable `scroll-step' has a non-zero value, an attempt is made to
1229 scroll the buffer by that many lines; if that is enough to bring point
1230 back into visibility, that is what happens.
1232 Scrolling happens automatically if point has moved out of the visible
1233 portion of the text when it is time to display. Usually scrolling is
1234 done to put point vertically centered within the window. However, if
1235 the variable `scroll-step' has a non-zero value, an attempt is made to
1236 scroll the buffer by that many lines; if that is enough to bring point
1237 back into visibility, that is what happens.
1239 If you set `scroll-step' to a small value because you want to use
1240 arrow keys to scroll the screen without recentering, the redisplay
1241 preemption will likely make XEmacs keep recentering the screen when
1242 scrolling fast, regardless of `scroll-step'. To prevent this, set
1243 `scroll-conservatively' to a small value, which will have the result of
1244 overriding the redisplay preemption.
projects / chise / xemacs-chise.git- / blob