Commit | Line | Data |
---|---|---|
6bf7aab6 | 1 | @c This is part of the Emacs manual. |
acaf905b | 2 | @c Copyright (C) 1985-1987, 1993-1995, 1997, 2000-2012 |
8838673e | 3 | @c Free Software Foundation, Inc. |
6bf7aab6 | 4 | @c See file emacs.texi for copying conditions. |
6bf7aab6 | 5 | |
abb9615e | 6 | @node Killing |
1f67b1dd | 7 | @chapter Killing and Moving Text |
6bf7aab6 | 8 | |
4d45a8b7 CY |
9 | In Emacs, @dfn{killing} means erasing text and copying it into the |
10 | @dfn{kill ring}. @dfn{Yanking} means bringing text from the kill ring | |
11 | back into the buffer. (Some applications use the terms ``cutting'' | |
12 | and ``pasting'' for similar operations.) The kill ring is so-named | |
13 | because it can be visualized as a set of blocks of text arranged in a | |
14 | ring, which you can access in cyclic order. @xref{Kill Ring}. | |
15 | ||
16 | Killing and yanking are the most common way to move or copy text | |
17 | within Emacs. It is very versatile, because there are commands for | |
18 | killing many different types of syntactic units. | |
1f67b1dd | 19 | |
b103c904 CY |
20 | @menu |
21 | * Deletion and Killing:: Commands that remove text. | |
22 | * Yanking:: Commands that insert text. | |
4d45a8b7 | 23 | * Cut and Paste:: Clipboard and selections on graphical displays. |
b103c904 CY |
24 | * Accumulating Text:: Other methods to add text to the buffer. |
25 | * Rectangles:: Operating on text in rectangular areas. | |
6cfd0fa2 | 26 | * CUA Bindings:: Using @kbd{C-x}/@kbd{C-c}/@kbd{C-v} to kill and yank. |
b103c904 CY |
27 | @end menu |
28 | ||
29 | @node Deletion and Killing | |
6bf7aab6 DL |
30 | @section Deletion and Killing |
31 | ||
32 | @cindex killing text | |
33 | @cindex cutting text | |
34 | @cindex deletion | |
1f67b1dd | 35 | Most commands which erase text from the buffer save it in the kill |
4d45a8b7 CY |
36 | ring. These are known as @dfn{kill} commands, and their names |
37 | normally contain the word @samp{kill} (e.g. @code{kill-line}). The | |
38 | kill ring stores several recent kills, not just the last one, so | |
39 | killing is a very safe operation: you don't have to worry much about | |
40 | losing text that you previously killed. The kill ring is shared by | |
41 | all buffers, so text that is killed in one buffer can be yanked into | |
42 | another buffer. | |
43 | ||
44 | When you use @kbd{C-/} (@code{undo}) to undo a kill command | |
45 | (@pxref{Undo}), that brings the killed text back into the buffer, but | |
46 | does not remove it from the kill ring. | |
7e9bf756 | 47 | |
4d45a8b7 CY |
48 | On graphical displays, killing text also copies it to the system |
49 | clipboard. @xref{Cut and Paste}. | |
7e9bf756 CY |
50 | |
51 | Commands that erase text but do not save it in the kill ring are | |
4d45a8b7 CY |
52 | known as @dfn{delete} commands; their names usually contain the word |
53 | @samp{delete}. These include @kbd{C-d} (@code{delete-char}) and | |
54 | @key{DEL} (@code{delete-backward-char}), which delete only one | |
55 | character at a time, and those commands that delete only spaces or | |
56 | newlines. Commands that can erase significant amounts of nontrivial | |
57 | data generally do a kill operation instead. | |
6bf7aab6 | 58 | |
a21cc7d1 RS |
59 | You can also use the mouse to kill and yank. @xref{Cut and Paste}. |
60 | ||
6bf7aab6 DL |
61 | @menu |
62 | * Deletion:: Commands for deleting small amounts of text and | |
63 | blank areas. | |
64 | * Killing by Lines:: How to kill entire lines of text at one time. | |
65 | * Other Kill Commands:: Commands to kill large regions of text and | |
177c0ea7 | 66 | syntactic units such as words and sentences. |
91ed7ea8 | 67 | * Kill Options:: Options that affect killing. |
6bf7aab6 DL |
68 | @end menu |
69 | ||
70 | @node Deletion | |
71 | @subsection Deletion | |
6bf7aab6 DL |
72 | @findex delete-backward-char |
73 | @findex delete-char | |
6bf7aab6 | 74 | |
ba5d9bfd RS |
75 | Deletion means erasing text and not saving it in the kill ring. For |
76 | the most part, the Emacs commands that delete text are those that | |
77 | erase just one character or only whitespace. | |
78 | ||
6bf7aab6 | 79 | @table @kbd |
6bf7aab6 | 80 | @item @key{DEL} |
7e9bf756 | 81 | @itemx @key{Backspace} |
50b063c3 CY |
82 | Delete the previous character, or the text in the region if it is |
83 | active (@code{delete-backward-char}). | |
84 | ||
85 | @item @key{Delete} | |
86 | Delete the next character, or the text in the region if it is active | |
87 | (@code{delete-forward-char}). | |
88 | ||
89 | @item C-d | |
90 | Delete the next character (@code{delete-char}). | |
91 | ||
6bf7aab6 DL |
92 | @item M-\ |
93 | Delete spaces and tabs around point (@code{delete-horizontal-space}). | |
94 | @item M-@key{SPC} | |
95 | Delete spaces and tabs around point, leaving one space | |
96 | (@code{just-one-space}). | |
97 | @item C-x C-o | |
98 | Delete blank lines around the current line (@code{delete-blank-lines}). | |
99 | @item M-^ | |
100 | Join two lines by deleting the intervening newline, along with any | |
101 | indentation following it (@code{delete-indentation}). | |
102 | @end table | |
103 | ||
50b063c3 CY |
104 | We have already described the basic deletion commands @key{DEL} |
105 | (@code{delete-backward-char}), @key{delete} | |
106 | (@code{delete-forward-char}), and @kbd{C-d} (@code{delete-char}). | |
107 | @xref{Erasing}. With a numeric argument, they delete the specified | |
108 | number of characters. If the numeric argument is omitted or one, they | |
109 | delete all the text in the region if it is active (@pxref{Using | |
110 | Region}). | |
4933bc02 | 111 | |
6bf7aab6 DL |
112 | @kindex M-\ |
113 | @findex delete-horizontal-space | |
114 | @kindex M-SPC | |
115 | @findex just-one-space | |
7e9bf756 | 116 | The other delete commands are those that delete only whitespace |
6bf7aab6 DL |
117 | characters: spaces, tabs and newlines. @kbd{M-\} |
118 | (@code{delete-horizontal-space}) deletes all the spaces and tab | |
f111a3c6 CY |
119 | characters before and after point. With a prefix argument, this only |
120 | deletes spaces and tab characters before point. @kbd{M-@key{SPC}} | |
21100e7d | 121 | (@code{just-one-space}) does likewise but leaves a single space before |
80b9df3a RS |
122 | point, regardless of the number of spaces that existed previously |
123 | (even if there were none before). With a numeric argument @var{n}, it | |
21100e7d CY |
124 | leaves @var{n} spaces before point if @var{n} is positive; if @var{n} |
125 | is negative, it deletes newlines in addition to spaces and tabs, | |
126 | leaving a single space before point. | |
6bf7aab6 DL |
127 | |
128 | @kbd{C-x C-o} (@code{delete-blank-lines}) deletes all blank lines | |
129 | after the current line. If the current line is blank, it deletes all | |
130 | blank lines preceding the current line as well (leaving one blank line, | |
fda95b3d | 131 | the current line). On a solitary blank line, it deletes that line. |
6bf7aab6 DL |
132 | |
133 | @kbd{M-^} (@code{delete-indentation}) joins the current line and the | |
134 | previous line, by deleting a newline and all surrounding spaces, usually | |
135 | leaving a single space. @xref{Indentation,M-^}. | |
136 | ||
137 | @node Killing by Lines | |
138 | @subsection Killing by Lines | |
139 | ||
140 | @table @kbd | |
141 | @item C-k | |
142 | Kill rest of line or one or more lines (@code{kill-line}). | |
533286e0 EZ |
143 | @item C-S-backspace |
144 | Kill an entire line at once (@code{kill-whole-line}) | |
6bf7aab6 DL |
145 | @end table |
146 | ||
147 | @kindex C-k | |
148 | @findex kill-line | |
4d45a8b7 CY |
149 | The simplest kill command is @kbd{C-k} (@code{kill-line}). If used |
150 | at the end of a line, it kills the line-ending newline character, | |
151 | merging the next line into the current one (thus, a blank line is | |
152 | entirely removed). Otherwise, @kbd{C-k} kills all the text from point | |
153 | up to the end of the line; if point was originally at the beginning of | |
154 | the line, this leaves the line blank. | |
155 | ||
156 | Spaces and tabs at the end of the line are ignored when deciding | |
157 | which case applies. As long as point is after the last visible | |
7e9bf756 CY |
158 | character in the line, you can be sure that @kbd{C-k} will kill the |
159 | newline. To kill an entire non-blank line, go to the beginning and | |
160 | type @kbd{C-k} twice. | |
161 | ||
4d45a8b7 CY |
162 | In this context, ``line'' means a logical text line, not a screen |
163 | line (@pxref{Continuation Lines}). | |
164 | ||
7e9bf756 CY |
165 | When @kbd{C-k} is given a positive argument @var{n}, it kills |
166 | @var{n} lines and the newlines that follow them (text on the current | |
167 | line before point is not killed). With a negative argument | |
168 | @minus{}@var{n}, it kills @var{n} lines preceding the current line, | |
169 | together with the text on the current line before point. @kbd{C-k} | |
170 | with an argument of zero kills the text before point on the current | |
171 | line. | |
6bf7aab6 DL |
172 | |
173 | @vindex kill-whole-line | |
174 | If the variable @code{kill-whole-line} is non-@code{nil}, @kbd{C-k} at | |
175 | the very beginning of a line kills the entire line including the | |
176 | following newline. This variable is normally @code{nil}. | |
177 | ||
533286e0 EZ |
178 | @kindex C-S-backspace |
179 | @findex kill-whole-line | |
4d45a8b7 CY |
180 | @kbd{C-S-backspace} (@code{kill-whole-line}) kills a whole line |
181 | including its newline, regardless of the position of point within the | |
182 | line. Note that many text terminals will prevent you from typing the | |
183 | key sequence @kbd{C-S-backspace}. | |
533286e0 | 184 | |
6bf7aab6 DL |
185 | @node Other Kill Commands |
186 | @subsection Other Kill Commands | |
187 | @findex kill-region | |
188 | @kindex C-w | |
189 | ||
6bf7aab6 DL |
190 | @table @kbd |
191 | @item C-w | |
50b063c3 | 192 | Kill the region (@code{kill-region}). |
7e9bf756 | 193 | @item M-w |
50b063c3 | 194 | Copy the region into the kill ring (@code{kill-ring-save}). |
6bf7aab6 | 195 | @item M-d |
50b063c3 | 196 | Kill the next word (@code{kill-word}). @xref{Words}. |
6bf7aab6 | 197 | @item M-@key{DEL} |
50b063c3 | 198 | Kill one word backwards (@code{backward-kill-word}). |
6bf7aab6 DL |
199 | @item C-x @key{DEL} |
200 | Kill back to beginning of sentence (@code{backward-kill-sentence}). | |
201 | @xref{Sentences}. | |
202 | @item M-k | |
50b063c3 | 203 | Kill to the end of the sentence (@code{kill-sentence}). |
6bf7aab6 | 204 | @item C-M-k |
46497336 | 205 | Kill the following balanced expression (@code{kill-sexp}). @xref{Expressions}. |
6bf7aab6 DL |
206 | @item M-z @var{char} |
207 | Kill through the next occurrence of @var{char} (@code{zap-to-char}). | |
208 | @end table | |
209 | ||
50b063c3 CY |
210 | @kindex C-w |
211 | @findex kill-region | |
7e9bf756 CY |
212 | @kindex M-w |
213 | @findex kill-ring-save | |
50b063c3 CY |
214 | One of the commonly-used kill commands is @kbd{C-w} |
215 | (@code{kill-region}), which kills the text in the region | |
216 | (@pxref{Mark}). Similarly, @kbd{M-w} (@code{kill-ring-save}) copies | |
217 | the text in the region into the kill ring without removing it from the | |
218 | buffer. If the mark is inactive when you type @kbd{C-w} or @kbd{M-w}, | |
219 | the command acts on the text between point and where you last set the | |
220 | mark (@pxref{Using Region}). | |
7e9bf756 CY |
221 | |
222 | Emacs also provides commands to kill specific syntactic units: | |
223 | words, with @kbd{M-@key{DEL}} and @kbd{M-d} (@pxref{Words}); balanced | |
224 | expressions, with @kbd{C-M-k} (@pxref{Expressions}); and sentences, | |
225 | with @kbd{C-x @key{DEL}} and @kbd{M-k} (@pxref{Sentences}). | |
6bf7aab6 DL |
226 | |
227 | @kindex M-z | |
228 | @findex zap-to-char | |
7e9bf756 CY |
229 | The command @kbd{M-z} (@code{zap-to-char}) combines killing with |
230 | searching: it reads a character and kills from point up to (and | |
6bf7aab6 | 231 | including) the next occurrence of that character in the buffer. A |
7e9bf756 | 232 | numeric argument acts as a repeat count; a negative argument means to |
6bf7aab6 DL |
233 | search backward and kill text before point. |
234 | ||
91ed7ea8 CY |
235 | @node Kill Options |
236 | @subsection Options for Killing | |
237 | ||
238 | @vindex kill-read-only-ok | |
239 | @cindex read-only text, killing | |
240 | Some specialized buffers contain @dfn{read-only text}, which cannot | |
4d45a8b7 CY |
241 | be modified and therefore cannot be killed. The kill commands work |
242 | specially in a read-only buffer: they move over text and copy it to | |
91ed7ea8 | 243 | the kill ring, without actually deleting it from the buffer. |
4d45a8b7 | 244 | Normally, they also beep and display an error message when this |
91ed7ea8 CY |
245 | happens. But if you set the variable @code{kill-read-only-ok} to a |
246 | non-@code{nil} value, they just print a message in the echo area to | |
247 | explain why the text has not been erased. | |
248 | ||
249 | @vindex kill-do-not-save-duplicates | |
250 | If you change the variable @code{kill-do-not-save-duplicates} to a | |
251 | non-@code{nil} value, identical subsequent kills yield a single | |
252 | kill-ring entry, without duplication. | |
253 | ||
b103c904 | 254 | @node Yanking |
6bf7aab6 DL |
255 | @section Yanking |
256 | @cindex moving text | |
257 | @cindex copying text | |
258 | @cindex kill ring | |
259 | @cindex yanking | |
260 | @cindex pasting | |
261 | ||
7e9bf756 | 262 | @dfn{Yanking} means reinserting text previously killed. The usual |
50b063c3 | 263 | way to move or copy text is to kill it and then yank it elsewhere. |
6bf7aab6 DL |
264 | |
265 | @table @kbd | |
266 | @item C-y | |
50b063c3 | 267 | Yank the last kill into the buffer, at point (@code{yank}). |
6bf7aab6 | 268 | @item M-y |
50b063c3 CY |
269 | Replace the text just yanked with an earlier batch of killed text |
270 | (@code{yank-pop}). @xref{Earlier Kills}. | |
6bf7aab6 | 271 | @item C-M-w |
50b063c3 CY |
272 | Cause the following command, if it is a kill command, to append to the |
273 | previous kill (@code{append-next-kill}). @xref{Appending Kills}. | |
6bf7aab6 DL |
274 | @end table |
275 | ||
50b063c3 CY |
276 | @kindex C-y |
277 | @findex yank | |
278 | The basic yanking command is @kbd{C-y} (@code{yank}). It inserts | |
279 | the most recent kill, leaving the cursor at the end of the inserted | |
280 | text. It also sets the mark at the beginning of the inserted text, | |
281 | without activating the mark; this lets you jump easily to that | |
282 | position, if you wish, with @kbd{C-u C-@key{SPC}} (@pxref{Mark Ring}). | |
283 | ||
284 | With a plain prefix argument (@kbd{C-u C-y}), the command instead | |
285 | leaves the cursor in front of the inserted text, and sets the mark at | |
286 | the end. Using any other prefix argument specifies an earlier kill; | |
287 | e.g. @kbd{C-u 4 C-y} reinserts the fourth most recent kill. | |
288 | @xref{Earlier Kills}. | |
289 | ||
290 | On graphical displays, @kbd{C-y} first checks if another application | |
291 | has placed any text in the system clipboard more recently than the | |
4ef1567b | 292 | last Emacs kill. If so, it inserts the clipboard's text instead. |
50b063c3 CY |
293 | Thus, Emacs effectively treats ``cut'' or ``copy'' clipboard |
294 | operations performed in other applications like Emacs kills, except | |
295 | that they are not recorded in the kill ring. @xref{Cut and Paste}, | |
296 | for details. | |
7464a646 | 297 | |
6bf7aab6 | 298 | @menu |
50b063c3 | 299 | * Kill Ring:: Where killed text is stored. |
8838673e | 300 | * Earlier Kills:: Yanking something killed some time ago. |
50b063c3 | 301 | * Appending Kills:: Several kills in a row all yank together. |
6bf7aab6 DL |
302 | @end menu |
303 | ||
304 | @node Kill Ring | |
305 | @subsection The Kill Ring | |
306 | ||
4d45a8b7 CY |
307 | The @dfn{kill ring} is a list of blocks of text that were previously |
308 | killed. There is only one kill ring, shared by all buffers, so you | |
309 | can kill text in one buffer and yank it in another buffer. This is | |
50b063c3 | 310 | the usual way to move text from one buffer to another. (There are |
4d45a8b7 CY |
311 | several other methods: for instance, you could store the text in a |
312 | register; see @ref{Registers}. @xref{Accumulating Text}, for some | |
313 | other ways to move text around.) | |
6bf7aab6 | 314 | |
50b063c3 CY |
315 | @vindex kill-ring-max |
316 | The maximum number of entries in the kill ring is controlled by the | |
317 | variable @code{kill-ring-max}. The default is 60. If you make a new | |
318 | kill when this limit has been reached, Emacs makes room by deleting | |
319 | the oldest entry in the kill ring. | |
4d45a8b7 | 320 | |
50b063c3 CY |
321 | @vindex kill-ring |
322 | The actual contents of the kill ring are stored in a variable named | |
323 | @code{kill-ring}; you can view the entire contents of the kill ring | |
324 | with @kbd{C-h v kill-ring}. | |
325 | ||
326 | @node Earlier Kills | |
327 | @subsection Yanking Earlier Kills | |
328 | @cindex yanking previous kills | |
329 | ||
330 | As explained in @ref{Yanking}, you can use a numeric argument to | |
331 | @kbd{C-y} to yank text that is no longer the most recent kill. This | |
332 | is useful if you remember which kill ring entry you want. If you | |
333 | don't, you can use the @kbd{M-y} (@code{yank-pop}) command to cycle | |
334 | through the possibilities. | |
335 | ||
336 | @kindex M-y | |
337 | @findex yank-pop | |
338 | If the previous command was a yank command, @kbd{M-y} takes the text | |
339 | that was yanked and replaces it with the text from an earlier kill. | |
340 | So, to recover the text of the next-to-the-last kill, first use | |
341 | @kbd{C-y} to yank the last kill, and then use @kbd{M-y} to replace it | |
342 | with the previous kill. @kbd{M-y} is allowed only after a @kbd{C-y} | |
343 | or another @kbd{M-y}. | |
344 | ||
345 | You can understand @kbd{M-y} in terms of a ``last yank'' pointer which | |
346 | points at an entry in the kill ring. Each time you kill, the ``last | |
347 | yank'' pointer moves to the newly made entry at the front of the ring. | |
348 | @kbd{C-y} yanks the entry which the ``last yank'' pointer points to. | |
349 | @kbd{M-y} moves the ``last yank'' pointer to a different entry, and the | |
350 | text in the buffer changes to match. Enough @kbd{M-y} commands can move | |
351 | the pointer to any entry in the ring, so you can get any entry into the | |
352 | buffer. Eventually the pointer reaches the end of the ring; the next | |
353 | @kbd{M-y} loops back around to the first entry again. | |
354 | ||
355 | @kbd{M-y} moves the ``last yank'' pointer around the ring, but it does | |
356 | not change the order of the entries in the ring, which always runs from | |
357 | the most recent kill at the front to the oldest one still remembered. | |
358 | ||
359 | @kbd{M-y} can take a numeric argument, which tells it how many entries | |
360 | to advance the ``last yank'' pointer by. A negative argument moves the | |
361 | pointer toward the front of the ring; from the front of the ring, it | |
362 | moves ``around'' to the last entry and continues forward from there. | |
363 | ||
364 | Once the text you are looking for is brought into the buffer, you can | |
365 | stop doing @kbd{M-y} commands and it will stay there. It's just a copy | |
366 | of the kill ring entry, so editing it in the buffer does not change | |
367 | what's in the ring. As long as no new killing is done, the ``last | |
368 | yank'' pointer remains at the same place in the kill ring, so repeating | |
369 | @kbd{C-y} will yank another copy of the same previous kill. | |
4d45a8b7 | 370 | |
50b063c3 CY |
371 | When you call @kbd{C-y} with a numeric argument, that also sets the |
372 | ``last yank'' pointer to the entry that it yanks. | |
6bf7aab6 DL |
373 | |
374 | @node Appending Kills | |
375 | @subsection Appending Kills | |
376 | ||
377 | @cindex appending kills in the ring | |
6bf7aab6 DL |
378 | Normally, each kill command pushes a new entry onto the kill ring. |
379 | However, two or more kill commands in a row combine their text into a | |
380 | single entry, so that a single @kbd{C-y} yanks all the text as a unit, | |
381 | just as it was before it was killed. | |
382 | ||
383 | Thus, if you want to yank text as a unit, you need not kill all of it | |
384 | with one command; you can keep killing line after line, or word after | |
385 | word, until you have killed it all, and you can still get it all back at | |
386 | once. | |
387 | ||
388 | Commands that kill forward from point add onto the end of the previous | |
389 | killed text. Commands that kill backward from point add text onto the | |
390 | beginning. This way, any sequence of mixed forward and backward kill | |
391 | commands puts all the killed text into one entry without rearrangement. | |
392 | Numeric arguments do not break the sequence of appending kills. For | |
393 | example, suppose the buffer contains this text: | |
394 | ||
395 | @example | |
396 | This is a line @point{}of sample text. | |
397 | @end example | |
398 | ||
399 | @noindent | |
400 | with point shown by @point{}. If you type @kbd{M-d M-@key{DEL} M-d | |
401 | M-@key{DEL}}, killing alternately forward and backward, you end up with | |
402 | @samp{a line of sample} as one entry in the kill ring, and @samp{This | |
58fa012d EZ |
403 | is@ @ text.} in the buffer. (Note the double space between @samp{is} |
404 | and @samp{text}, which you can clean up with @kbd{M-@key{SPC}} or | |
405 | @kbd{M-q}.) | |
6bf7aab6 DL |
406 | |
407 | Another way to kill the same text is to move back two words with | |
408 | @kbd{M-b M-b}, then kill all four words forward with @kbd{C-u M-d}. | |
409 | This produces exactly the same results in the buffer and in the kill | |
410 | ring. @kbd{M-f M-f C-u M-@key{DEL}} kills the same text, all going | |
411 | backward; once again, the result is the same. The text in the kill ring | |
412 | entry always has the same order that it had in the buffer before you | |
413 | killed it. | |
414 | ||
415 | @kindex C-M-w | |
416 | @findex append-next-kill | |
417 | If a kill command is separated from the last kill command by other | |
418 | commands (not just numeric arguments), it starts a new entry on the kill | |
419 | ring. But you can force it to append by first typing the command | |
420 | @kbd{C-M-w} (@code{append-next-kill}) right before it. The @kbd{C-M-w} | |
421 | tells the following command, if it is a kill command, to append the text | |
422 | it kills to the last killed text, instead of starting a new entry. With | |
423 | @kbd{C-M-w}, you can kill several separated pieces of text and | |
424 | accumulate them to be yanked back in one place.@refill | |
425 | ||
7e9bf756 CY |
426 | A kill command following @kbd{M-w} (@code{kill-ring-save}) does not |
427 | append to the text that @kbd{M-w} copied into the kill ring. | |
6bf7aab6 | 428 | |
4d45a8b7 CY |
429 | @node Cut and Paste |
430 | @section ``Cut and Paste'' Operations on Graphical Displays | |
431 | @cindex cut | |
432 | @cindex copy | |
433 | @cindex paste | |
434 | ||
435 | In most graphical desktop environments, you can transfer data | |
436 | (usually text) between different applications using a system facility | |
437 | called the @dfn{clipboard}. On X, two other similar facilities are | |
438 | available: the primary selection and the secondary selection. When | |
439 | Emacs is run on a graphical display, its kill and yank commands | |
440 | integrate with these facilities, so that you can easily transfer text | |
441 | between Emacs and other graphical applications. | |
442 | ||
443 | By default, Emacs uses UTF-8 as the coding system for inter-program | |
444 | text transfers. If you find that the pasted text is not what you | |
445 | expected, you can specify another coding system by typing @kbd{C-x | |
446 | @key{RET} x} or @kbd{C-x @key{RET} X}. You can also request a | |
447 | different data type by customizing @code{x-select-request-type}. | |
448 | @xref{Communication Coding}. | |
449 | ||
450 | @menu | |
451 | * Clipboard:: How Emacs uses the system clipboard. | |
452 | * Primary Selection:: The temporarily selected text selection. | |
453 | * Secondary Selection:: Cutting without altering point and mark. | |
454 | @end menu | |
455 | ||
456 | @node Clipboard | |
457 | @subsection Using the Clipboard | |
458 | @cindex clipboard | |
459 | ||
460 | The @dfn{clipboard} is the facility that most graphical applications | |
461 | use for ``cutting and pasting''. When the clipboard exists, the kill | |
462 | and yank commands in Emacs make use of it. | |
463 | ||
464 | When you kill some text with a command such as @kbd{C-w} | |
465 | (@code{kill-region}), or copy it to the kill ring with a command such | |
466 | as @kbd{M-w} (@code{kill-ring-save}), that text is also put in the | |
50b063c3 | 467 | clipboard. |
4d45a8b7 CY |
468 | |
469 | @vindex save-interprogram-paste-before-kill | |
470 | When an Emacs kill command puts text in the clipboard, the existing | |
471 | clipboard contents are normally lost. Optionally, you can change | |
472 | @code{save-interprogram-paste-before-kill} to @code{t}. Then Emacs | |
473 | will first save the clipboard to its kill ring, preventing you from | |
474 | losing the old clipboard data---at the risk of high memory consumption | |
475 | if that data turns out to be large. | |
476 | ||
50b063c3 CY |
477 | Yank commands, such as @kbd{C-y} (@code{yank}), also use the |
478 | clipboard. If another application ``owns'' the clipboard---i.e., if | |
479 | you cut or copied text there more recently than your last kill command | |
480 | in Emacs---then Emacs yanks from the clipboard instead of the kill | |
481 | ring. | |
4d45a8b7 CY |
482 | |
483 | @vindex yank-pop-change-selection | |
484 | Normally, rotating the kill ring with @kbd{M-y} (@code{yank-pop}) | |
485 | does not alter the clipboard. However, if you change | |
486 | @code{yank-pop-change-selection} to @code{t}, then @kbd{M-y} saves the | |
487 | new yank to the clipboard. | |
488 | ||
489 | @vindex x-select-enable-clipboard | |
490 | To prevent kill and yank commands from accessing the clipboard, | |
491 | change the variable @code{x-select-enable-clipboard} to @code{nil}. | |
a08a07e3 CY |
492 | |
493 | @cindex clipboard manager | |
494 | @vindex x-select-enable-clipboard-manager | |
495 | Many X desktop environments support a feature called the | |
496 | @dfn{clipboard manager}. If you exit Emacs while it is the current | |
497 | ``owner'' of the clipboard data, and there is a clipboard manager | |
498 | running, Emacs transfers the clipboard data to the clipboard manager | |
499 | so that it is not lost. In some circumstances, this may cause a delay | |
500 | when exiting Emacs; if you wish to prevent Emacs from transferring | |
501 | data to the clipboard manager, change the variable | |
502 | @code{x-select-enable-clipboard-manager} to @code{nil}. | |
4d45a8b7 CY |
503 | |
504 | @vindex x-select-enable-primary | |
505 | @findex clipboard-kill-region | |
506 | @findex clipboard-kill-ring-save | |
507 | @findex clipboard-yank | |
508 | Prior to Emacs 24, the kill and yank commands used the primary | |
509 | selection (@pxref{Primary Selection}), not the clipboard. If you | |
510 | prefer this behavior, change @code{x-select-enable-clipboard} to | |
511 | @code{nil}, @code{x-select-enable-primary} to @code{t}, and | |
512 | @code{mouse-drag-copy-region} to @code{t}. In this case, you can use | |
513 | the following commands to act explicitly on the clipboard: | |
514 | @code{clipboard-kill-region} kills the region and saves it to the | |
515 | clipboard; @code{clipboard-kill-ring-save} copies the region to the | |
516 | kill ring and saves it to the clipboard; and @code{clipboard-yank} | |
517 | yanks the contents of the clipboard at point. | |
518 | ||
519 | @node Primary Selection | |
520 | @subsection Cut and Paste with Other Window Applications | |
521 | @cindex X cutting and pasting | |
522 | @cindex X selection | |
523 | @cindex primary selection | |
524 | @cindex selection, primary | |
525 | ||
50b063c3 | 526 | Under the X Window System, there exists a @dfn{primary selection} |
4d45a8b7 CY |
527 | containing the last stretch of text selected in an X application |
528 | (usually by dragging the mouse). Typically, this text can be inserted | |
529 | into other X applications by @kbd{mouse-2} clicks. The primary | |
50b063c3 CY |
530 | selection is separate from the clipboard. Its contents are more |
531 | ``fragile''; they are overwritten each time you select text with the | |
532 | mouse, whereas the clipboard is only overwritten by explicit ``cut'' | |
533 | or ``copy'' commands. | |
4d45a8b7 | 534 | |
50b063c3 CY |
535 | Under X, whenever the region is active (@pxref{Mark}), the text in |
536 | the region is saved in the primary selection. This applies regardless | |
537 | of whether the region was made by dragging or clicking the mouse | |
538 | (@pxref{Mouse Commands}), or by keyboard commands (e.g. by typing | |
539 | @kbd{C-@key{SPC}} and moving point; @pxref{Setting Mark}). | |
4d45a8b7 CY |
540 | |
541 | @vindex select-active-regions | |
963578d3 CY |
542 | If you change the variable @code{select-active-regions} to |
543 | @code{only}, Emacs saves only temporarily active regions to the | |
544 | primary selection, i.e. those made with the mouse or with shift | |
545 | selection (@pxref{Shift Selection}). If you change | |
546 | @code{select-active-regions} to @code{nil}, Emacs avoids saving active | |
547 | regions to the primary selection entirely. | |
4d45a8b7 CY |
548 | |
549 | To insert the primary selection into an Emacs buffer, click | |
550 | @kbd{mouse-2} (@code{mouse-yank-primary}) where you want to insert it. | |
551 | @xref{Mouse Commands}. | |
552 | ||
553 | @cindex MS-Windows, and primary selection | |
554 | MS-Windows provides no primary selection, but Emacs emulates it | |
555 | within a single Emacs session by storing the selected text internally. | |
556 | Therefore, all the features and commands related to the primary | |
557 | selection work on Windows as they do on X, for cutting and pasting | |
558 | within the same session, but not across Emacs sessions or with other | |
559 | applications. | |
560 | ||
561 | @node Secondary Selection | |
562 | @subsection Secondary Selection | |
563 | @cindex secondary selection | |
564 | ||
565 | In addition to the primary selection, the X Window System provides a | |
566 | second similar facility known as the @dfn{secondary selection}. | |
567 | Nowadays, few X applications make use of the secondary selection, but | |
568 | you can access it using the following Emacs commands: | |
569 | ||
570 | @table @kbd | |
571 | @findex mouse-set-secondary | |
572 | @kindex M-Drag-Mouse-1 | |
573 | @item M-Drag-Mouse-1 | |
574 | Set the secondary selection, with one end at the place where you press | |
575 | down the button, and the other end at the place where you release it | |
576 | (@code{mouse-set-secondary}). The selected text is highlighted, using | |
577 | the @code{secondary-selection} face, as you drag. The window scrolls | |
578 | automatically if you drag the mouse off the top or bottom of the | |
579 | window, just like @code{mouse-set-region} (@pxref{Mouse Commands}). | |
580 | ||
581 | This command does not alter the kill ring. | |
582 | ||
583 | @findex mouse-start-secondary | |
584 | @kindex M-Mouse-1 | |
585 | @item M-Mouse-1 | |
586 | Set one endpoint for the @dfn{secondary selection} | |
587 | (@code{mouse-start-secondary}). | |
588 | ||
589 | @findex mouse-secondary-save-then-kill | |
590 | @kindex M-Mouse-3 | |
591 | @item M-Mouse-3 | |
592 | Set the secondary selection, with one end at the position clicked and | |
593 | the other at the position specified with @kbd{M-Mouse-1} | |
594 | (@code{mouse-secondary-save-then-kill}). This also puts the selected | |
595 | text in the kill ring. A second @kbd{M-Mouse-3} at the same place | |
596 | kills the secondary selection just made. | |
597 | ||
598 | @findex mouse-yank-secondary | |
599 | @kindex M-Mouse-2 | |
600 | @item M-Mouse-2 | |
601 | Insert the secondary selection where you click, placing point at the | |
602 | end of the yanked text (@code{mouse-yank-secondary}). | |
603 | @end table | |
604 | ||
605 | Double or triple clicking of @kbd{M-Mouse-1} operates on words and | |
606 | lines, much like @kbd{Mouse-1}. | |
607 | ||
608 | If @code{mouse-yank-at-point} is non-@code{nil}, @kbd{M-Mouse-2} yanks | |
609 | at point. Then it does not matter precisely where you click, or even | |
610 | which of the frame's windows you click on. @xref{Mouse Commands}. | |
611 | ||
b103c904 | 612 | @node Accumulating Text |
6bf7aab6 DL |
613 | @section Accumulating Text |
614 | @findex append-to-buffer | |
615 | @findex prepend-to-buffer | |
616 | @findex copy-to-buffer | |
617 | @findex append-to-file | |
618 | ||
619 | @cindex accumulating scattered text | |
620 | Usually we copy or move text by killing it and yanking it, but there | |
3423ce02 | 621 | are other convenient methods for copying one block of text in many |
7e9bf756 CY |
622 | places, or for copying many scattered blocks of text into one place. |
623 | Here we describe the commands to accumulate scattered pieces of text | |
624 | into a buffer or into a file. | |
6bf7aab6 DL |
625 | |
626 | @table @kbd | |
627 | @item M-x append-to-buffer | |
0ec1f115 | 628 | Append region to the contents of a specified buffer. |
6bf7aab6 | 629 | @item M-x prepend-to-buffer |
0ec1f115 | 630 | Prepend region to the contents of a specified buffer. |
6bf7aab6 | 631 | @item M-x copy-to-buffer |
58fa012d | 632 | Copy region into a specified buffer, deleting that buffer's old contents. |
6bf7aab6 | 633 | @item M-x insert-buffer |
0ec1f115 | 634 | Insert the contents of a specified buffer into current buffer at point. |
6bf7aab6 | 635 | @item M-x append-to-file |
0ec1f115 | 636 | Append region to the contents of a specified file, at the end. |
6bf7aab6 DL |
637 | @end table |
638 | ||
639 | To accumulate text into a buffer, use @kbd{M-x append-to-buffer}. | |
640 | This reads a buffer name, then inserts a copy of the region into the | |
641 | buffer specified. If you specify a nonexistent buffer, | |
642 | @code{append-to-buffer} creates the buffer. The text is inserted | |
643 | wherever point is in that buffer. If you have been using the buffer for | |
644 | editing, the copied text goes into the middle of the text of the buffer, | |
58fa012d | 645 | starting from wherever point happens to be at that moment. |
6bf7aab6 DL |
646 | |
647 | Point in that buffer is left at the end of the copied text, so | |
648 | successive uses of @code{append-to-buffer} accumulate the text in the | |
649 | specified buffer in the same order as they were copied. Strictly | |
650 | speaking, @code{append-to-buffer} does not always append to the text | |
50b063c3 CY |
651 | already in the buffer---it appends only if point in that buffer is at |
652 | the end. However, if @code{append-to-buffer} is the only command you | |
653 | use to alter a buffer, then point is always at the end. | |
6bf7aab6 DL |
654 | |
655 | @kbd{M-x prepend-to-buffer} is just like @code{append-to-buffer} | |
656 | except that point in the other buffer is left before the copied text, so | |
657 | successive prependings add text in reverse order. @kbd{M-x | |
58fa012d | 658 | copy-to-buffer} is similar, except that any existing text in the other |
6bf7aab6 DL |
659 | buffer is deleted, so the buffer is left containing just the text newly |
660 | copied into it. | |
661 | ||
4c987d71 CY |
662 | The command @kbd{M-x insert-buffer} can be used to retrieve the |
663 | accumulated text from another buffer. This prompts for the name of a | |
664 | buffer, and inserts a copy of all the text in that buffer into the | |
665 | current buffer at point, leaving point at the beginning of the | |
666 | inserted text. It also adds the position of the end of the inserted | |
667 | text to the mark ring, without activating the mark. @xref{Buffers}, | |
668 | for background information on buffers. | |
6bf7aab6 | 669 | |
7e9bf756 CY |
670 | Instead of accumulating text in a buffer, you can append text |
671 | directly into a file with @kbd{M-x append-to-file}. This prompts for | |
672 | a filename, and adds the text of the region to the end of the | |
673 | specified file. The file is changed immediately on disk. | |
6bf7aab6 DL |
674 | |
675 | You should use @code{append-to-file} only with files that are | |
676 | @emph{not} being visited in Emacs. Using it on a file that you are | |
677 | editing in Emacs would change the file behind Emacs's back, which | |
678 | can lead to losing some of your editing. | |
679 | ||
7e9bf756 CY |
680 | Another way to move text around is to store it in a register. |
681 | @xref{Registers}. | |
682 | ||
b103c904 | 683 | @node Rectangles |
6bf7aab6 DL |
684 | @section Rectangles |
685 | @cindex rectangle | |
686 | @cindex columns (and rectangles) | |
687 | @cindex killing rectangular areas of text | |
688 | ||
7e9bf756 CY |
689 | @dfn{Rectangle} commands operate on rectangular areas of the text: |
690 | all the characters between a certain pair of columns, in a certain | |
691 | range of lines. Emacs has commands to kill rectangles, yank killed | |
692 | rectangles, clear them out, fill them with blanks or text, or delete | |
693 | them. Rectangle commands are useful with text in multicolumn formats, | |
694 | and for changing text into or out of such formats. | |
6bf7aab6 | 695 | |
077b72a4 | 696 | @cindex mark rectangle |
50b063c3 CY |
697 | To specify a rectangle for a command to work on, set the mark at one |
698 | corner and point at the opposite corner. The rectangle thus specified | |
699 | is called the @dfn{region-rectangle}. If point and the mark are in | |
700 | the same column, the region-rectangle is empty. If they are in the | |
701 | same line, the region-rectangle is one line high. | |
702 | ||
703 | The region-rectangle is controlled in much the same way as the | |
704 | region is controlled. But remember that a given combination of point | |
705 | and mark values can be interpreted either as a region or as a | |
706 | rectangle, depending on the command that uses them. | |
6bf7aab6 DL |
707 | |
708 | @table @kbd | |
709 | @item C-x r k | |
177c0ea7 | 710 | Kill the text of the region-rectangle, saving its contents as the |
6bf7aab6 | 711 | ``last killed rectangle'' (@code{kill-rectangle}). |
48de8b12 CY |
712 | @item C-x r M-w |
713 | Save the text of the region-rectangle as the ``last killed rectangle'' | |
714 | (@code{copy-rectangle-as-kill}). | |
6bf7aab6 DL |
715 | @item C-x r d |
716 | Delete the text of the region-rectangle (@code{delete-rectangle}). | |
717 | @item C-x r y | |
718 | Yank the last killed rectangle with its upper left corner at point | |
719 | (@code{yank-rectangle}). | |
720 | @item C-x r o | |
721 | Insert blank space to fill the space of the region-rectangle | |
722 | (@code{open-rectangle}). This pushes the previous contents of the | |
50b063c3 CY |
723 | region-rectangle to the right. |
724 | @item C-x r N | |
725 | Insert line numbers along the left edge of the region-rectangle | |
726 | (@code{rectangle-number-lines}). This pushes the previous contents of | |
727 | the region-rectangle to the right. | |
3b4d49d7 | 728 | @item C-x r c |
df7593dd | 729 | Clear the region-rectangle by replacing all of its contents with spaces |
3b4d49d7 | 730 | (@code{clear-rectangle}). |
6bf7aab6 DL |
731 | @item M-x delete-whitespace-rectangle |
732 | Delete whitespace in each of the lines on the specified rectangle, | |
733 | starting from the left edge column of the rectangle. | |
d621caf7 | 734 | @item C-x r t @var{string} @key{RET} |
df7593dd | 735 | Replace rectangle contents with @var{string} on each line |
6bf7aab6 | 736 | (@code{string-rectangle}). |
1e1e6d52 | 737 | @item M-x string-insert-rectangle @key{RET} @var{string} @key{RET} |
e9db3bf2 | 738 | Insert @var{string} on each line of the rectangle. |
6bf7aab6 DL |
739 | @end table |
740 | ||
50b063c3 CY |
741 | The rectangle operations fall into two classes: commands to erase or |
742 | insert rectangles, and commands to make blank rectangles. | |
6bf7aab6 DL |
743 | |
744 | @kindex C-x r k | |
745 | @kindex C-x r d | |
746 | @findex kill-rectangle | |
747 | @findex delete-rectangle | |
50b063c3 CY |
748 | There are two ways to erase the text in a rectangle: @kbd{C-x r d} |
749 | (@code{delete-rectangle}) to delete the text outright, or @kbd{C-x r | |
58179cce | 750 | k} (@code{kill-rectangle}) to remove the text and save it as the |
50b063c3 CY |
751 | @dfn{last killed rectangle}. In both cases, erasing the |
752 | region-rectangle is like erasing the specified text on each line of | |
bfd779dd | 753 | the rectangle; if there is any following text on the line, it moves |
50b063c3 CY |
754 | backwards to fill the gap. |
755 | ||
756 | ``Killing'' a rectangle is not killing in the usual sense; the | |
6bf7aab6 | 757 | rectangle is not stored in the kill ring, but in a special place that |
50b063c3 CY |
758 | only records the most recent rectangle killed. This is because |
759 | yanking a rectangle is so different from yanking linear text that | |
760 | different yank commands have to be used. Yank-popping is not defined | |
761 | for rectangles. | |
6bf7aab6 | 762 | |
48de8b12 CY |
763 | @kindex C-x r M-w |
764 | @findex copy-rectangle-as-kill | |
765 | @kbd{C-x r M-w} (@code{copy-rectangle-as-kill}) is the equivalent of | |
766 | @kbd{M-w} for rectangles: it records the rectangle as the ``last | |
767 | killed rectangle'', without deleting the text from the buffer. | |
768 | ||
6bf7aab6 DL |
769 | @kindex C-x r y |
770 | @findex yank-rectangle | |
771 | To yank the last killed rectangle, type @kbd{C-x r y} | |
50b063c3 CY |
772 | (@code{yank-rectangle}). The rectangle's first line is inserted at |
773 | point, the rectangle's second line is inserted at the same horizontal | |
774 | position one line vertically below, and so on. The number of lines | |
775 | affected is determined by the height of the saved rectangle. | |
776 | ||
777 | For example, you can convert two single-column lists into a | |
778 | double-column list by killing one of the single-column lists as a | |
779 | rectangle, and then yanking it beside the other list. | |
6bf7aab6 DL |
780 | |
781 | You can also copy rectangles into and out of registers with @kbd{C-x r | |
a30ed87b | 782 | r @var{r}} and @kbd{C-x r i @var{r}}. @xref{Rectangle Registers}. |
6bf7aab6 DL |
783 | |
784 | @kindex C-x r o | |
785 | @findex open-rectangle | |
3b4d49d7 | 786 | @kindex C-x r c |
6bf7aab6 DL |
787 | @findex clear-rectangle |
788 | There are two commands you can use for making blank rectangles: | |
50b063c3 CY |
789 | @kbd{C-x r c} (@code{clear-rectangle}) blanks out existing text in the |
790 | region-rectangle, and @kbd{C-x r o} (@code{open-rectangle}) inserts a | |
791 | blank rectangle. | |
6bf7aab6 DL |
792 | |
793 | @findex delete-whitespace-rectangle | |
50b063c3 CY |
794 | @kbd{M-x delete-whitespace-rectangle} deletes horizontal whitespace |
795 | starting from a particular column. This applies to each of the lines | |
796 | in the rectangle, and the column is specified by the left edge of the | |
797 | rectangle. The right edge of the rectangle does not make any | |
798 | difference to this command. | |
799 | ||
800 | @kindex C-x r N | |
801 | @findex rectangle | |
802 | The command @kbd{C-x r N} (@code{rectangle-number-lines}) inserts | |
803 | line numbers along the left edge of the region-rectangle. Normally, | |
804 | the numbering begins from 1 (for the first line of the rectangle). | |
805 | With a prefix argument, the command prompts for a number to begin | |
806 | from, and for a format string with which to print the numbers | |
807 | (@pxref{Formatting Strings,,, elisp, The Emacs Lisp Reference | |
808 | Manual}). | |
6bf7aab6 DL |
809 | |
810 | @kindex C-x r t | |
811 | @findex string-rectangle | |
d57211a3 | 812 | The command @kbd{C-x r t} (@code{string-rectangle}) replaces the |
1e1e6d52 GM |
813 | contents of a region-rectangle with a string on each line. The |
814 | string's width need not be the same as the width of the rectangle. If | |
815 | the string's width is less, the text after the rectangle shifts left; | |
816 | if the string is wider than the rectangle, the text after the | |
817 | rectangle shifts right. | |
818 | ||
819 | @findex string-insert-rectangle | |
177c0ea7 JB |
820 | The command @kbd{M-x string-insert-rectangle} is similar to |
821 | @code{string-rectangle}, but inserts the string on each line, | |
1e1e6d52 | 822 | shifting the original text to the right. |
ab5796a9 | 823 | |
b103c904 | 824 | @node CUA Bindings |
38fe0612 | 825 | @section CUA Bindings |
95a0306c KS |
826 | @findex cua-mode |
827 | @vindex cua-mode | |
828 | @cindex CUA key bindings | |
829 | @vindex cua-enable-cua-keys | |
830 | The command @kbd{M-x cua-mode} sets up key bindings that are | |
831 | compatible with the Common User Access (CUA) system used in many other | |
50b063c3 CY |
832 | applications. |
833 | ||
834 | When CUA mode is enabled, the keys @kbd{C-x}, @kbd{C-c}, @kbd{C-v}, | |
835 | and @kbd{C-z} invoke commands that cut (kill), copy, paste (yank), and | |
836 | undo respectively. The @kbd{C-x} and @kbd{C-c} keys perform cut and | |
837 | copy only if the region is active. Otherwise, they still act as | |
838 | prefix keys, so that standard Emacs commands like @kbd{C-x C-c} still | |
839 | work. Note that this means the variable @code{mark-even-if-inactive} | |
840 | has no effect for @kbd{C-x} and @kbd{C-c} (@pxref{Using Region}). | |
95a0306c | 841 | |
144e981a RS |
842 | To enter an Emacs command like @kbd{C-x C-f} while the mark is |
843 | active, use one of the following methods: either hold @kbd{Shift} | |
844 | together with the prefix key, e.g. @kbd{S-C-x C-f}, or quickly type | |
845 | the prefix key twice, e.g. @kbd{C-x C-x C-f}. | |
95a0306c | 846 | |
50b063c3 CY |
847 | To disable the overriding of standard Emacs binding by CUA mode, |
848 | while retaining the other features of CUA mode described below, set | |
849 | the variable @code{cua-enable-cua-keys} to @code{nil}. | |
850 | ||
7e9bf756 CY |
851 | In CUA mode, typed text replaces the active region as in |
852 | Delete-Selection mode (@pxref{Mouse Commands}). | |
853 | ||
95a0306c KS |
854 | @cindex rectangle highlighting |
855 | CUA mode provides enhanced rectangle support with visible | |
856 | rectangle highlighting. Use @kbd{C-RET} to start a rectangle, | |
857 | extend it using the movement commands, and cut or copy it using | |
19126168 KS |
858 | @kbd{C-x} or @kbd{C-c}. @kbd{RET} moves the cursor to the next |
859 | (clockwise) corner of the rectangle, so you can easily expand it in | |
860 | any direction. Normal text you type is inserted to the left or right | |
861 | of each line in the rectangle (on the same side as the cursor). | |
95a0306c KS |
862 | |
863 | With CUA you can easily copy text and rectangles into and out of | |
40b6cb79 | 864 | registers by providing a one-digit numeric prefix to the kill, copy, |
95a0306c KS |
865 | and yank commands, e.g. @kbd{C-1 C-c} copies the region into register |
866 | @code{1}, and @kbd{C-2 C-v} yanks the contents of register @code{2}. | |
867 | ||
868 | @cindex global mark | |
869 | CUA mode also has a global mark feature which allows easy moving and | |
870 | copying of text between buffers. Use @kbd{C-S-SPC} to toggle the | |
871 | global mark on and off. When the global mark is on, all text that you | |
872 | kill or copy is automatically inserted at the global mark, and text | |
873 | you type is inserted at the global mark rather than at the current | |
874 | position. | |
875 | ||
876 | For example, to copy words from various buffers into a word list in | |
877 | a given buffer, set the global mark in the target buffer, then | |
878 | navigate to each of the words you want in the list, mark it (e.g. with | |
879 | @kbd{S-M-f}), copy it to the list with @kbd{C-c} or @kbd{M-w}, and | |
880 | insert a newline after the word in the target list by pressing | |
881 | @key{RET}. |