[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to killing.texi
|
From: |
Glenn Morris |
|
Subject: |
[Emacs-diffs] Changes to killing.texi |
|
Date: |
Thu, 06 Sep 2007 04:37:44 +0000 |
CVSROOT: /sources/emacs
Module name: emacs
Changes by: Glenn Morris <gm> 07/09/06 04:37:44
Index: killing.texi
===================================================================
RCS file: killing.texi
diff -N killing.texi
--- killing.texi 11 Apr 2007 20:57:52 -0000 1.60
+++ /dev/null 1 Jan 1970 00:00:00 -0000
@@ -1,699 +0,0 @@
address@hidden This is part of the Emacs manual.
address@hidden Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000,
2001,
address@hidden 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation,
Inc.
address@hidden See file emacs.texi for copying conditions.
-
address@hidden Killing, Yanking, Mark, Top
address@hidden Killing and Moving Text
-
address@hidden
address@hidden
address@hidden ifnottex
-
- @dfn{Killing} means erasing text and copying it into the @dfn{kill
-ring}, from which you can bring it back into the buffer by
address@hidden it. (Some systems use the terms ``cutting'' and
-``pasting'' for these operations.) This is the most common way of
-moving or copying text within Emacs. Killing and yanking is very safe
-because Emacs remembers several recent kills, not just the last one.
-It is versatile, because the many commands for killing syntactic units
-can also be used for moving those units. But there are other ways of
-copying text for special purposes.
-
address@hidden
address@hidden Deletion and Killing
address@hidden iftex
-
address@hidden killing text
address@hidden cutting text
address@hidden deletion
- Most commands which erase text from the buffer save it in the kill
-ring. These commands are known as @dfn{kill} commands. The commands
-that erase text but do not save it in the kill ring are known as
address@hidden commands. The @kbd{C-x u} (@code{undo}) command
-(@pxref{Undo}) can undo both kill and delete commands; the importance
-of the kill ring is that you can also yank the text in a different
-place or places. Emacs has only one kill ring for all buffers, so you
-can kill text in one buffer and yank it in another buffer.
-
- The delete commands include @kbd{C-d} (@code{delete-char}) and
address@hidden (@code{delete-backward-char}), which delete only one
-character at a time, and those commands that delete only spaces or
-newlines. Commands that can erase significant amounts of nontrivial
-data generally do a kill operation instead. The commands' names and
-individual descriptions use the words @samp{kill} and @samp{delete} to
-say which kind of operation they perform.
-
address@hidden kill-read-only-ok
address@hidden read-only text, killing
- You cannot kill read-only text, since such text does not allow any
-kind of modification. But some users like to use the kill commands to
-copy read-only text into the kill ring, without actually changing it.
-Therefore, the kill commands work specially in a read-only buffer:
-they move over text, and copy it to the kill ring, without actually
-deleting it from the buffer. Normally, kill commands beep and display
-an error message when this happens. But if you set the variable
address@hidden to a address@hidden value, they just print a
-message in the echo area to explain why the text has not been erased.
-
- You can also use the mouse to kill and yank. @xref{Cut and Paste}.
-
address@hidden
-* Deletion:: Commands for deleting small amounts of text and
- blank areas.
-* Killing by Lines:: How to kill entire lines of text at one time.
-* Other Kill Commands:: Commands to kill large regions of text and
- syntactic units such as words and sentences.
address@hidden menu
-
address@hidden 1500
address@hidden Deletion
address@hidden Deletion
address@hidden delete-backward-char
address@hidden delete-char
-
- Deletion means erasing text and not saving it in the kill ring. For
-the most part, the Emacs commands that delete text are those that
-erase just one character or only whitespace.
-
address@hidden @kbd
address@hidden C-d
address@hidden @key{DELETE}
-Delete next character (@code{delete-char}). If your keyboard has a
address@hidden function key (usually located in the edit keypad), Emacs
-binds it to @code{delete-char} as well.
address@hidden @key{DEL}
address@hidden @key{BS}
-Delete previous character (@code{delete-backward-char}).
address@hidden M-\
-Delete spaces and tabs around point (@code{delete-horizontal-space}).
address@hidden address@hidden
-Delete spaces and tabs around point, leaving one space
-(@code{just-one-space}).
address@hidden C-x C-o
-Delete blank lines around the current line (@code{delete-blank-lines}).
address@hidden M-^
-Join two lines by deleting the intervening newline, along with any
-indentation following it (@code{delete-indentation}).
address@hidden table
-
address@hidden DEL
address@hidden C-d
- The most basic delete commands are @kbd{C-d} (@code{delete-char}) and
address@hidden (@code{delete-backward-char}). @kbd{C-d} deletes the
-character after point, the one the cursor is ``on top of.'' This
-doesn't move point. @key{DEL} deletes the character before the cursor,
-and moves point back. You can delete newlines like any other characters
-in the buffer; deleting a newline joins two lines. Actually, @kbd{C-d}
-and @key{DEL} aren't always delete commands; when given arguments, they
-kill instead, since they can erase more than one character this way.
-
address@hidden BACKSPACE
address@hidden BS
address@hidden DELETE
- Every keyboard has a large key which is a short distance above the
address@hidden or @key{ENTER} key and is normally used for erasing what you
-have typed. It may be labeled @key{DEL}, @key{BACKSPACE}, @key{BS},
address@hidden, or even with a left arrow. Regardless of the label on
-the key, in Emacs it called @key{DEL}, and it should delete one
-character backwards.
-
- Many keyboards (including standard PC keyboards) have a
address@hidden key a short ways above @key{RET} or @key{ENTER}, and a
address@hidden key elsewhere. In that case, the @key{BACKSPACE} key is
address@hidden, and the @key{DELETE} key is equivalent to @kbd{C-d}---or it
-should be.
-
- Why do we say ``or it should be''? When Emacs starts up using a
-graphical display, it determines automatically which key or keys should be
-equivalent to @key{DEL}. As a result, @key{BACKSPACE} and/or @key{DELETE}
-keys normally do the right things. But in some unusual cases Emacs
-gets the wrong information from the system. If these keys don't do
-what they ought to do, you need to tell Emacs which key to use for
address@hidden @xref{DEL Does Not Delete}, for how to do this.
-
address@hidden normal-erase-is-backspace-mode
- On most text-only terminals, Emacs cannot tell which keys the
-keyboard really has, so it follows a uniform plan which may or may not
-fit your keyboard. The uniform plan is that the @acronym{ASCII} @key{DEL}
-character deletes, and the @acronym{ASCII} @key{BS} (backspace) character asks
-for help (it is the same as @kbd{C-h}). If this is not right for your
-keyboard, such as if you find that the key which ought to delete backwards
-enters Help instead, see @ref{DEL Does Not Delete}.
-
address@hidden M-\
address@hidden delete-horizontal-space
address@hidden M-SPC
address@hidden just-one-space
- The other delete commands are those which delete only whitespace
-characters: spaces, tabs and newlines. @kbd{M-\}
-(@code{delete-horizontal-space}) deletes all the spaces and tab
-characters before and after point. With a prefix argument, this only
-deletes spaces and tab characters before point. @address@hidden
-(@code{just-one-space}) does likewise but leaves a single space after
-point, regardless of the number of spaces that existed previously
-(even if there were none before). With a numeric argument @var{n}, it
-leaves @var{n} spaces after point.
-
- @kbd{C-x C-o} (@code{delete-blank-lines}) deletes all blank lines
-after the current line. If the current line is blank, it deletes all
-blank lines preceding the current line as well (leaving one blank line,
-the current line). On a solitary blank line, it deletes that line.
-
- @kbd{M-^} (@code{delete-indentation}) joins the current line and the
-previous line, by deleting a newline and all surrounding spaces, usually
-leaving a single space. @xref{Indentation,M-^}.
-
address@hidden Killing by Lines
address@hidden Killing by Lines
-
address@hidden @kbd
address@hidden C-k
-Kill rest of line or one or more lines (@code{kill-line}).
address@hidden C-S-backspace
-Kill an entire line at once (@code{kill-whole-line})
address@hidden table
-
address@hidden C-k
address@hidden kill-line
- The simplest kill command is @kbd{C-k}. If given at the beginning of
-a line, it kills all the text on the line, leaving it blank. When used
-on a blank line, it kills the whole line including its newline. To kill
-an entire non-blank line, go to the beginning and type @kbd{C-k} twice.
-
- More generally, @kbd{C-k} kills from point up to the end of the line,
-unless it is at the end of a line. In that case it kills the newline
-following point, thus merging the next line into the current one.
-Spaces and tabs that you can't see at the end of the line are ignored
-when deciding which case applies, so if point appears to be at the end
-of the line, you can be sure @kbd{C-k} will kill the newline.
-
- When @kbd{C-k} is given a positive argument, it kills that many lines
-and the newlines that follow them (however, text on the current line
-before point is not killed). With a negative argument @address@hidden, it
-kills @var{n} lines preceding the current line (together with the text
-on the current line before point). Thus, @kbd{C-u - 2 C-k} at the front
-of a line kills the two previous lines.
-
- @kbd{C-k} with an argument of zero kills the text before point on the
-current line.
-
address@hidden kill-whole-line
- If the variable @code{kill-whole-line} is address@hidden, @kbd{C-k} at
-the very beginning of a line kills the entire line including the
-following newline. This variable is normally @code{nil}.
-
address@hidden C-S-backspace
address@hidden kill-whole-line
- @kbd{C-S-backspace} (@code{kill-whole-line}) will kill a whole line
-including its newline regardless of the position of point within the
-line. Note that many character terminals will prevent you from typing
-the key sequence @kbd{C-S-backspace}.
-
address@hidden Other Kill Commands
address@hidden Other Kill Commands
address@hidden kill-region
address@hidden C-w
-
address@hidden @kbd
address@hidden C-w
-Kill region (from point to the mark) (@code{kill-region}).
address@hidden M-d
-Kill word (@code{kill-word}). @xref{Words}.
address@hidden address@hidden
-Kill word backwards (@code{backward-kill-word}).
address@hidden C-x @key{DEL}
-Kill back to beginning of sentence (@code{backward-kill-sentence}).
address@hidden
address@hidden M-k
-Kill to end of sentence (@code{kill-sentence}).
address@hidden C-M-k
-Kill the following balanced expression (@code{kill-sexp}). @xref{Expressions}.
address@hidden M-z @var{char}
-Kill through the next occurrence of @var{char} (@code{zap-to-char}).
address@hidden table
-
- The most general kill command is @kbd{C-w} (@code{kill-region}),
-which kills everything between point and the mark. With this command,
-you can kill any contiguous sequence of characters, if you first set
-the region around them.
-
address@hidden M-z
address@hidden zap-to-char
- A convenient way of killing is combined with searching: @kbd{M-z}
-(@code{zap-to-char}) reads a character and kills from point up to (and
-including) the next occurrence of that character in the buffer. A
-numeric argument acts as a repeat count. A negative argument means to
-search backward and kill text before point.
-
- Other syntactic units can be killed: words, with @address@hidden
-and @kbd{M-d} (@pxref{Words}); balanced expressions, with @kbd{C-M-k}
-(@pxref{Expressions}); and sentences, with @kbd{C-x @key{DEL}} and
address@hidden (@pxref{Sentences})address@hidden
-
address@hidden Yanking, Accumulating Text, Killing, Top
address@hidden Yanking
address@hidden moving text
address@hidden copying text
address@hidden kill ring
address@hidden yanking
address@hidden pasting
-
- @dfn{Yanking} means reinserting text previously killed. This is what
-some systems call ``pasting.'' The usual way to move or copy text is to
-kill it and then yank it elsewhere one or more times. This is very safe
-because Emacs remembers many recent kills, not just the last one.
-
address@hidden @kbd
address@hidden C-y
-Yank last killed text (@code{yank}).
address@hidden M-y
-Replace text just yanked with an earlier batch of killed text
-(@code{yank-pop}).
address@hidden M-w
-Save region as last killed text without actually killing it
-(@code{kill-ring-save}). Some systems call this ``copying.''
address@hidden C-M-w
-Append next kill to last batch of killed text (@code{append-next-kill}).
address@hidden table
-
- On graphical displays with window systems, if there is a current
-selection in some other application, and you selected it more recently
-than you killed any text in Emacs, @kbd{C-y} copies the selection
-instead of text killed within Emacs.
-
address@hidden
-* Kill Ring:: Where killed text is stored. Basic yanking.
-* Appending Kills:: Several kills in a row all yank together.
-* Earlier Kills:: Yanking something killed some time ago.
address@hidden menu
-
address@hidden Kill Ring
address@hidden The Kill Ring
-
- All killed text is recorded in the @dfn{kill ring}, a list of blocks of
-text that have been killed. There is only one kill ring, shared by all
-buffers, so you can kill text in one buffer and yank it in another buffer.
-This is the usual way to move text from one file to another.
-(@xref{Accumulating Text}, for some other ways.)
-
address@hidden C-y
address@hidden yank
- The command @kbd{C-y} (@code{yank}) reinserts the text of the most recent
-kill. It leaves the cursor at the end of the text. It sets the mark at
-the beginning of the text. @xref{Mark}.
-
- @kbd{C-u C-y} leaves the cursor in front of the text, and sets the
-mark after it. This happens only if the argument is specified with just
-a @kbd{C-u}, precisely. Any other sort of argument, including @kbd{C-u}
-and digits, specifies an earlier kill to yank (@pxref{Earlier Kills}).
-
address@hidden yanking and text properties
address@hidden yank-excluded-properties
- The yank commands discard certain text properties from the text that
-is yanked, those that might lead to annoying results. For instance,
-they discard text properties that respond to the mouse or specify key
-bindings. The variable @code{yank-excluded-properties} specifies the
-properties to discard. Yanking of register contents and rectangles
-also discard these properties.
-
address@hidden M-w
address@hidden kill-ring-save
- To copy a block of text, you can use @kbd{M-w}
-(@code{kill-ring-save}), which copies the region into the kill ring
-without removing it from the buffer. This is approximately equivalent
-to @kbd{C-w} followed by @kbd{C-x u}, except that @kbd{M-w} does not
-alter the undo history and does not temporarily change the screen.
-
address@hidden Appending Kills
address@hidden Appending Kills
-
address@hidden appending kills in the ring
address@hidden television
- Normally, each kill command pushes a new entry onto the kill ring.
-However, two or more kill commands in a row combine their text into a
-single entry, so that a single @kbd{C-y} yanks all the text as a unit,
-just as it was before it was killed.
-
- Thus, if you want to yank text as a unit, you need not kill all of it
-with one command; you can keep killing line after line, or word after
-word, until you have killed it all, and you can still get it all back at
-once.
-
- Commands that kill forward from point add onto the end of the previous
-killed text. Commands that kill backward from point add text onto the
-beginning. This way, any sequence of mixed forward and backward kill
-commands puts all the killed text into one entry without rearrangement.
-Numeric arguments do not break the sequence of appending kills. For
-example, suppose the buffer contains this text:
-
address@hidden
-This is a line @point{}of sample text.
address@hidden example
-
address@hidden
-with point shown by @point{}. If you type @kbd{M-d address@hidden M-d
address@hidden, killing alternately forward and backward, you end up with
address@hidden line of sample} as one entry in the kill ring, and @samp{This
-is@ @ text.} in the buffer. (Note the double space between @samp{is}
-and @samp{text}, which you can clean up with @address@hidden or
address@hidden)
-
- Another way to kill the same text is to move back two words with
address@hidden M-b}, then kill all four words forward with @kbd{C-u M-d}.
-This produces exactly the same results in the buffer and in the kill
-ring. @kbd{M-f M-f C-u address@hidden kills the same text, all going
-backward; once again, the result is the same. The text in the kill ring
-entry always has the same order that it had in the buffer before you
-killed it.
-
address@hidden C-M-w
address@hidden append-next-kill
- If a kill command is separated from the last kill command by other
-commands (not just numeric arguments), it starts a new entry on the kill
-ring. But you can force it to append by first typing the command
address@hidden (@code{append-next-kill}) right before it. The @kbd{C-M-w}
-tells the following command, if it is a kill command, to append the text
-it kills to the last killed text, instead of starting a new entry. With
address@hidden, you can kill several separated pieces of text and
-accumulate them to be yanked back in one address@hidden
-
- A kill command following @kbd{M-w} does not append to the text that
address@hidden copied into the kill ring.
-
address@hidden Earlier Kills
address@hidden Yanking Earlier Kills
-
address@hidden yanking previous kills
address@hidden M-y
address@hidden yank-pop
- To recover killed text that is no longer the most recent kill, use the
address@hidden command (@code{yank-pop}). It takes the text previously
-yanked and replaces it with the text from an earlier kill. So, to
-recover the text of the next-to-the-last kill, first use @kbd{C-y} to
-yank the last kill, and then use @kbd{M-y} to replace it with the
-previous kill. @kbd{M-y} is allowed only after a @kbd{C-y} or another
address@hidden
-
- You can understand @kbd{M-y} in terms of a ``last yank'' pointer which
-points at an entry in the kill ring. Each time you kill, the ``last
-yank'' pointer moves to the newly made entry at the front of the ring.
address@hidden yanks the entry which the ``last yank'' pointer points to.
address@hidden moves the ``last yank'' pointer to a different entry, and the
-text in the buffer changes to match. Enough @kbd{M-y} commands can move
-the pointer to any entry in the ring, so you can get any entry into the
-buffer. Eventually the pointer reaches the end of the ring; the next
address@hidden loops back around to the first entry again.
-
- @kbd{M-y} moves the ``last yank'' pointer around the ring, but it does
-not change the order of the entries in the ring, which always runs from
-the most recent kill at the front to the oldest one still remembered.
-
- @kbd{M-y} can take a numeric argument, which tells it how many entries
-to advance the ``last yank'' pointer by. A negative argument moves the
-pointer toward the front of the ring; from the front of the ring, it
-moves ``around'' to the last entry and continues forward from there.
-
- Once the text you are looking for is brought into the buffer, you can
-stop doing @kbd{M-y} commands and it will stay there. It's just a copy
-of the kill ring entry, so editing it in the buffer does not change
-what's in the ring. As long as no new killing is done, the ``last
-yank'' pointer remains at the same place in the kill ring, so repeating
address@hidden will yank another copy of the same previous kill.
-
- If you know how many @kbd{M-y} commands it would take to find the
-text you want, you can yank that text in one step using @kbd{C-y} with
-a numeric argument. @kbd{C-y} with an argument restores the text from
-the specified kill ring entry, counting back from the most recent as
-1. Thus, @kbd{C-u 2 C-y} gets the next-to-the-last block of killed
-text---it is equivalent to @kbd{C-y M-y}. @kbd{C-y} with a numeric
-argument starts counting from the ``last yank'' pointer, and sets the
-``last yank'' pointer to the entry that it yanks.
-
address@hidden kill-ring-max
- The length of the kill ring is controlled by the variable
address@hidden; no more than that many blocks of killed text are
-saved.
-
address@hidden kill-ring
- The actual contents of the kill ring are stored in a variable named
address@hidden; you can view the entire contents of the kill ring with
-the command @kbd{C-h v kill-ring}.
-
address@hidden Accumulating Text, Rectangles, Yanking, Top
address@hidden Accumulating Text
address@hidden append-to-buffer
address@hidden prepend-to-buffer
address@hidden copy-to-buffer
address@hidden append-to-file
-
address@hidden accumulating scattered text
- Usually we copy or move text by killing it and yanking it, but there
-are other convenient methods for copying one block of text in many
-places, or for copying many scattered blocks of text into one place. To
-copy one block to many places, store it in a register
-(@pxref{Registers}). Here we describe the commands to accumulate
-scattered pieces of text into a buffer or into a file.
-
address@hidden @kbd
address@hidden M-x append-to-buffer
-Append region to the contents of a specified buffer.
address@hidden M-x prepend-to-buffer
-Prepend region to the contents of a specified buffer.
address@hidden M-x copy-to-buffer
-Copy region into a specified buffer, deleting that buffer's old contents.
address@hidden M-x insert-buffer
-Insert the contents of a specified buffer into current buffer at point.
address@hidden M-x append-to-file
-Append region to the contents of a specified file, at the end.
address@hidden table
-
- To accumulate text into a buffer, use @kbd{M-x append-to-buffer}.
-This reads a buffer name, then inserts a copy of the region into the
-buffer specified. If you specify a nonexistent buffer,
address@hidden creates the buffer. The text is inserted
-wherever point is in that buffer. If you have been using the buffer for
-editing, the copied text goes into the middle of the text of the buffer,
-starting from wherever point happens to be at that moment.
-
- Point in that buffer is left at the end of the copied text, so
-successive uses of @code{append-to-buffer} accumulate the text in the
-specified buffer in the same order as they were copied. Strictly
-speaking, @code{append-to-buffer} does not always append to the text
-already in the buffer---it appends only if point in that buffer is at the end.
-However, if @code{append-to-buffer} is the only command you use to alter
-a buffer, then point is always at the end.
-
- @kbd{M-x prepend-to-buffer} is just like @code{append-to-buffer}
-except that point in the other buffer is left before the copied text, so
-successive prependings add text in reverse order. @kbd{M-x
-copy-to-buffer} is similar, except that any existing text in the other
-buffer is deleted, so the buffer is left containing just the text newly
-copied into it.
-
- To retrieve the accumulated text from another buffer, use the
-command @kbd{M-x insert-buffer}; this too takes @var{buffername} as an
-argument. It inserts a copy of the whole text in buffer
address@hidden into the current buffer at point, and sets the mark
-after the inserted text. Alternatively, you can select the other
-buffer for editing, then copy text from it by killing.
address@hidden, for background information on buffers.
-
- Instead of accumulating text within Emacs, in a buffer, you can append
-text directly into a file with @kbd{M-x append-to-file}, which takes
address@hidden as an argument. It adds the text of the region to the end
-of the specified file. The file is changed immediately on disk.
-
- You should use @code{append-to-file} only with files that are
address@hidden being visited in Emacs. Using it on a file that you are
-editing in Emacs would change the file behind Emacs's back, which
-can lead to losing some of your editing.
-
address@hidden Rectangles, CUA Bindings, Accumulating Text, Top
address@hidden Rectangles
address@hidden rectangle
address@hidden columns (and rectangles)
address@hidden killing rectangular areas of text
-
- The rectangle commands operate on rectangular areas of the text: all
-the characters between a certain pair of columns, in a certain range of
-lines. Commands are provided to kill rectangles, yank killed rectangles,
-clear them out, fill them with blanks or text, or delete them. Rectangle
-commands are useful with text in multicolumn formats, and for changing
-text into or out of such formats.
-
address@hidden mark rectangle
- When you must specify a rectangle for a command to work on, you do it
-by putting the mark at one corner and point at the opposite corner. The
-rectangle thus specified is called the @dfn{region-rectangle} because
-you control it in much the same way as the region is controlled. But
-remember that a given combination of point and mark values can be
-interpreted either as a region or as a rectangle, depending on the
-command that uses them.
-
- If point and the mark are in the same column, the rectangle they
-delimit is empty. If they are in the same line, the rectangle is one
-line high. This asymmetry between lines and columns comes about
-because point (and likewise the mark) is between two columns, but within
-a line.
-
address@hidden @kbd
address@hidden C-x r k
-Kill the text of the region-rectangle, saving its contents as the
-``last killed rectangle'' (@code{kill-rectangle}).
address@hidden C-x r d
-Delete the text of the region-rectangle (@code{delete-rectangle}).
address@hidden C-x r y
-Yank the last killed rectangle with its upper left corner at point
-(@code{yank-rectangle}).
address@hidden C-x r o
-Insert blank space to fill the space of the region-rectangle
-(@code{open-rectangle}). This pushes the previous contents of the
-region-rectangle rightward.
address@hidden C-x r c
-Clear the region-rectangle by replacing all of its contents with spaces
-(@code{clear-rectangle}).
address@hidden M-x delete-whitespace-rectangle
-Delete whitespace in each of the lines on the specified rectangle,
-starting from the left edge column of the rectangle.
address@hidden C-x r t @var{string} @key{RET}
-Replace rectangle contents with @var{string} on each line
-(@code{string-rectangle}).
address@hidden M-x string-insert-rectangle @key{RET} @var{string} @key{RET}
-Insert @var{string} on each line of the rectangle.
address@hidden table
-
- The rectangle operations fall into two classes: commands for
-deleting and inserting rectangles, and commands for blank rectangles.
-
address@hidden C-x r k
address@hidden C-x r d
address@hidden kill-rectangle
address@hidden delete-rectangle
- There are two ways to get rid of the text in a rectangle: you can
-discard the text (delete it) or save it as the ``last killed''
-rectangle. The commands for these two ways are @kbd{C-x r d}
-(@code{delete-rectangle}) and @kbd{C-x r k} (@code{kill-rectangle}). In
-either case, the portion of each line that falls inside the rectangle's
-boundaries is deleted, causing any following text on the line to
-move left into the gap.
-
- Note that ``killing'' a rectangle is not killing in the usual sense; the
-rectangle is not stored in the kill ring, but in a special place that
-can only record the most recent rectangle killed. This is because yanking
-a rectangle is so different from yanking linear text that different yank
-commands have to be used. It is hard to define yank-popping for rectangles,
-so we do not try.
-
address@hidden C-x r y
address@hidden yank-rectangle
- To yank the last killed rectangle, type @kbd{C-x r y}
-(@code{yank-rectangle}). Yanking a rectangle is the opposite of killing
-one. Point specifies where to put the rectangle's upper left corner.
-The rectangle's first line is inserted there, the rectangle's second
-line is inserted at the same horizontal position, but one line
-vertically down, and so on. The number of lines affected is determined
-by the height of the saved rectangle.
-
- You can convert single-column lists into double-column lists using
-rectangle killing and yanking; kill the second half of the list as a
-rectangle and then yank it beside the first line of the list.
address@hidden, for another way to edit multi-column text.
-
- You can also copy rectangles into and out of registers with @kbd{C-x r
-r @var{r}} and @kbd{C-x r i @var{r}}. @xref{RegRect,,Rectangle
-Registers}.
-
address@hidden C-x r o
address@hidden open-rectangle
address@hidden C-x r c
address@hidden clear-rectangle
- There are two commands you can use for making blank rectangles:
address@hidden r c} (@code{clear-rectangle}) which blanks out existing text,
-and @kbd{C-x r o} (@code{open-rectangle}) which inserts a blank
-rectangle. Clearing a rectangle is equivalent to deleting it and then
-inserting a blank rectangle of the same size.
-
address@hidden delete-whitespace-rectangle
- The command @kbd{M-x delete-whitespace-rectangle} deletes horizontal
-whitespace starting from a particular column. This applies to each of
-the lines in the rectangle, and the column is specified by the left
-edge of the rectangle. The right edge of the rectangle does not make
-any difference to this command.
-
address@hidden C-x r t
address@hidden string-rectangle
- The command @kbd{C-x r t} (@code{string-rectangle}) replaces the
-contents of a region-rectangle with a string on each line. The
-string's width need not be the same as the width of the rectangle. If
-the string's width is less, the text after the rectangle shifts left;
-if the string is wider than the rectangle, the text after the
-rectangle shifts right.
-
address@hidden string-insert-rectangle
- The command @kbd{M-x string-insert-rectangle} is similar to
address@hidden, but inserts the string on each line,
-shifting the original text to the right.
-
address@hidden CUA Bindings, Registers, Rectangles, Top
address@hidden CUA Bindings
address@hidden cua-mode
address@hidden cua-mode
address@hidden CUA key bindings
address@hidden cua-enable-cua-keys
- The command @kbd{M-x cua-mode} sets up key bindings that are
-compatible with the Common User Access (CUA) system used in many other
-applications. @kbd{C-x} means cut (kill), @kbd{C-c} copy, @kbd{C-v}
-paste (yank), and @kbd{C-z} undo. Standard Emacs commands like
address@hidden C-c} still work, because @kbd{C-x} and @kbd{C-c} only take
-effect when the mark is active (and the region is highlighted).
-However, if you don't want to override these bindings in Emacs at all,
-set @code{cua-enable-cua-keys} to @code{nil}.
-
- In CUA mode, using @kbd{Shift} together with the movement keys
-activates and highlights the region over which they move. The
-standard (unshifted) movement keys deactivate the mark, and typed text
-replaces the active region as in Delete-Selection mode
-(@pxref{Mouse Commands}).
-
- To enter an Emacs command like @kbd{C-x C-f} while the mark is
-active, use one of the following methods: either hold @kbd{Shift}
-together with the prefix key, e.g. @kbd{S-C-x C-f}, or quickly type
-the prefix key twice, e.g. @kbd{C-x C-x C-f}.
-
address@hidden rectangle highlighting
- CUA mode provides enhanced rectangle support with visible
-rectangle highlighting. Use @kbd{C-RET} to start a rectangle,
-extend it using the movement commands, and cut or copy it using
address@hidden or @kbd{C-c}. @kbd{RET} moves the cursor to the next
-(clockwise) corner of the rectangle, so you can easily expand it in
-any direction. Normal text you type is inserted to the left or right
-of each line in the rectangle (on the same side as the cursor).
-
- With CUA you can easily copy text and rectangles into and out of
-registers by providing a one-digit numeric prefix to the kill, copy,
-and yank commands, e.g. @kbd{C-1 C-c} copies the region into register
address@hidden, and @kbd{C-2 C-v} yanks the contents of register @code{2}.
-
address@hidden global mark
- CUA mode also has a global mark feature which allows easy moving and
-copying of text between buffers. Use @kbd{C-S-SPC} to toggle the
-global mark on and off. When the global mark is on, all text that you
-kill or copy is automatically inserted at the global mark, and text
-you type is inserted at the global mark rather than at the current
-position.
-
- For example, to copy words from various buffers into a word list in
-a given buffer, set the global mark in the target buffer, then
-navigate to each of the words you want in the list, mark it (e.g. with
address@hidden), copy it to the list with @kbd{C-c} or @kbd{M-w}, and
-insert a newline after the word in the target list by pressing
address@hidden
-
address@hidden
address@hidden
address@hidden ifnottex
-
address@hidden
- arch-tag: d8da8f96-0928-449a-816e-ff2d3497866c
address@hidden ignore