Mercurial > vim
annotate runtime/doc/usr_24.txt @ 19663:f43c0e669bd6 v8.2.0388
patch 8.2.0388: printmbcharset option not tested
Commit: https://github.com/vim/vim/commit/833805a4867cf5f93b3ef91227d1f1a98f553dff
Author: Bram Moolenaar <Bram@vim.org>
Date: Sun Mar 15 18:27:43 2020 +0100
patch 8.2.0388: printmbcharset option not tested
Problem: Printmbcharset option not tested.
Solution: Add a test. Enable PostScript for AppVeyor build. (Dominique
Pelle, closes #5783)
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sun, 15 Mar 2020 18:30:05 +0100 |
| parents | 130acb903dbe |
| children | f8116058ca76 |
| rev | line source |
|---|---|
| 18879 | 1 *usr_24.txt* For Vim version 8.2. Last change: 2018 Mar 18 |
| 7 | 2 |
| 3 VIM USER MANUAL - by Bram Moolenaar | |
| 4 | |
| 5 Inserting quickly | |
| 6 | |
| 7 | |
| 8 When entering text, Vim offers various ways to reduce the number of keystrokes | |
| 9 and avoid typing mistakes. Use Insert mode completion to repeat previously | |
| 10 typed words. Abbreviate long words to short ones. Type characters that | |
| 11 aren't on your keyboard. | |
| 12 | |
| 13 |24.1| Making corrections | |
| 14 |24.2| Showing matches | |
| 15 |24.3| Completion | |
| 16 |24.4| Repeating an insert | |
| 17 |24.5| Copying from another line | |
| 18 |24.6| Inserting a register | |
| 19 |24.7| Abbreviations | |
| 20 |24.8| Entering special characters | |
| 21 |24.9| Digraphs | |
| 22 |24.10| Normal mode commands | |
| 23 | |
| 24 Next chapter: |usr_25.txt| Editing formatted text | |
| 25 Previous chapter: |usr_23.txt| Editing other files | |
| 26 Table of contents: |usr_toc.txt| | |
| 27 | |
| 28 ============================================================================== | |
| 29 *24.1* Making corrections | |
| 30 | |
| 31 The <BS> key was already mentioned. It deletes the character just before the | |
| 32 cursor. The <Del> key does the same for the character under (after) the | |
| 33 cursor. | |
| 34 When you typed a whole word wrong, use CTRL-W: | |
| 35 | |
| 36 The horse had fallen to the sky ~ | |
| 37 CTRL-W | |
| 38 The horse had fallen to the ~ | |
| 39 | |
| 40 If you really messed up a line and want to start over, use CTRL-U to delete | |
| 41 it. This keeps the text after the cursor and the indent. Only the text from | |
| 42 the first non-blank to the cursor is deleted. With the cursor on the "f" of | |
| 43 "fallen" in the next line pressing CTRL-U does this: | |
| 44 | |
| 45 The horse had fallen to the ~ | |
| 46 CTRL-U | |
| 47 fallen to the ~ | |
| 48 | |
| 49 When you spot a mistake a few words back, you need to move the cursor there to | |
| 50 correct it. For example, you typed this: | |
| 51 | |
| 52 The horse had follen to the ground ~ | |
| 53 | |
| 54 You need to change "follen" to "fallen". With the cursor at the end, you | |
| 55 would type this to correct it: > | |
| 56 | |
| 57 <Esc>4blraA | |
| 58 | |
| 59 < get out of Insert mode <Esc> | |
| 60 four words back 4b | |
| 61 move on top of the "o" l | |
| 62 replace with "a" ra | |
| 63 restart Insert mode A | |
| 64 | |
| 65 Another way to do this: > | |
| 66 | |
| 67 <C-Left><C-Left><C-Left><C-Left><Right><Del>a<End> | |
| 68 | |
| 69 < four words back <C-Left><C-Left><C-Left><C-Left> | |
| 70 move on top of the "o" <Right> | |
| 71 delete the "o" <Del> | |
| 72 insert an "a" a | |
| 73 go to end of the line <End> | |
| 74 | |
| 75 This uses special keys to move around, while remaining in Insert mode. This | |
| 76 resembles what you would do in a modeless editor. It's easier to remember, | |
| 77 but takes more time (you have to move your hand from the letters to the cursor | |
| 78 keys, and the <End> key is hard to press without looking at the keyboard). | |
| 79 These special keys are most useful when writing a mapping that doesn't | |
| 80 leave Insert mode. The extra typing doesn't matter then. | |
| 81 An overview of the keys you can use in Insert mode: | |
| 82 | |
| 83 <C-Home> to start of the file | |
| 84 <PageUp> a whole screenful up | |
| 85 <Home> to start of line | |
| 86 <S-Left> one word left | |
| 87 <C-Left> one word left | |
| 88 <S-Right> one word right | |
| 89 <C-Right> one word right | |
| 90 <End> to end of the line | |
| 91 <PageDown> a whole screenful down | |
| 92 <C-End> to end of the file | |
| 93 | |
| 94 There are a few more, see |ins-special-special|. | |
| 95 | |
| 96 ============================================================================== | |
| 97 *24.2* Showing matches | |
| 98 | |
| 99 When you type a ) it would be nice to see with which ( it matches. To make | |
| 100 Vim do that use this command: > | |
| 101 | |
| 102 :set showmatch | |
| 103 | |
| 104 When you now type a text like "(example)", as soon as you type the ) Vim will | |
| 105 briefly move the cursor to the matching (, keep it there for half a second, | |
| 106 and move back to where you were typing. | |
| 236 | 107 In case there is no matching (, Vim will beep. Then you know that you |
| 7 | 108 might have forgotten the ( somewhere, or typed a ) too many. |
| 109 The match will also be shown for [] and {} pairs. You don't have to wait | |
| 110 with typing the next character, as soon as Vim sees it the cursor will move | |
| 111 back and inserting continues as before. | |
| 112 You can change the time Vim waits with the 'matchtime' option. For | |
| 113 example, to make Vim wait one and a half second: > | |
| 114 | |
| 115 :set matchtime=15 | |
| 116 | |
| 117 The time is specified in tenths of a second. | |
| 118 | |
| 119 ============================================================================== | |
| 120 *24.3* Completion | |
| 121 | |
| 122 Vim can automatically complete words on insertion. You type the first part of | |
| 123 a word, press CTRL-P, and Vim guesses the rest. | |
| 124 Suppose, for example, that you are creating a C program and want to type in | |
| 125 the following: | |
| 126 | |
| 127 total = ch_array[0] + ch_array[1] + ch_array[2]; ~ | |
| 128 | |
| 129 You start by entering the following: | |
| 130 | |
| 131 total = ch_array[0] + ch_ ~ | |
| 132 | |
| 133 At this point, you tell Vim to complete the word using the command CTRL-P. | |
| 134 Vim searches for a word that starts with what's in front of the cursor. In | |
| 135 this case, it is "ch_", which matches with the word ch_array. So typing | |
| 136 CTRL-P gives you the following: | |
| 137 | |
| 138 total = ch_array[0] + ch_array ~ | |
| 139 | |
| 140 After a little more typing, you get this (ending in a space): | |
| 141 | |
| 142 total = ch_array[0] + ch_array[1] + ~ | |
| 143 | |
| 144 If you now type CTRL-P Vim will search again for a word that completes the | |
| 145 word before the cursor. Since there is nothing in front of the cursor, it | |
| 146 finds the first word backwards, which is "ch_array". Typing CTRL-P again | |
| 147 gives you the next word that matches, in this case "total". A third CTRL-P | |
| 148 searches further back. If there is nothing else, it causes the editor to run | |
| 149 out of words, so it returns to the original text, which is nothing. A fourth | |
| 150 CTRL-P causes the editor to start over again with "ch_array". | |
| 151 | |
| 152 To search forward, use CTRL-N. Since the search wraps around the end of the | |
| 153 file, CTRL-N and CTRL-P will find the same matches, but in a different | |
| 154 sequence. Hint: CTRL-N is Next-match and CTRL-P is Previous-match. | |
| 155 | |
| 156 The Vim editor goes through a lot of effort to find words to complete. By | |
| 157 default, it searches the following places: | |
| 158 | |
| 159 1. Current file | |
| 160 2. Files in other windows | |
| 161 3. Other loaded files (hidden buffers) | |
| 162 4. Files which are not loaded (inactive buffers) | |
| 163 5. Tag files | |
| 164 6. All files #included by the current file | |
| 165 | |
| 166 | |
| 167 OPTIONS | |
| 168 | |
| 169 You can customize the search order with the 'complete' option. | |
| 170 | |
| 171 The 'ignorecase' option is used. When it is set, case differences are ignored | |
| 172 when searching for matches. | |
| 173 | |
| 174 A special option for completion is 'infercase'. This is useful to find | |
| 175 matches while ignoring case ('ignorecase' must be set) but still using the | |
| 176 case of the word typed so far. Thus if you type "For" and Vim finds a match | |
| 177 "fortunately", it will result in "Fortunately". | |
| 178 | |
| 179 | |
| 180 COMPLETING SPECIFIC ITEMS | |
| 181 | |
| 182 If you know what you are looking for, you can use these commands to complete | |
| 183 with a certain type of item: | |
| 184 | |
| 185 CTRL-X CTRL-F file names | |
| 186 CTRL-X CTRL-L whole lines | |
| 187 CTRL-X CTRL-D macro definitions (also in included files) | |
| 188 CTRL-X CTRL-I current and included files | |
| 189 CTRL-X CTRL-K words from a dictionary | |
| 190 CTRL-X CTRL-T words from a thesaurus | |
| 191 CTRL-X CTRL-] tags | |
| 192 CTRL-X CTRL-V Vim command line | |
| 193 | |
| 194 After each of them CTRL-N can be used to find the next match, CTRL-P to find | |
| 195 the previous match. | |
| 196 More information for each of these commands here: |ins-completion|. | |
| 197 | |
| 198 | |
| 199 COMPLETING FILE NAMES | |
| 200 | |
| 201 Let's take CTRL-X CTRL-F as an example. This will find file names. It scans | |
| 202 the current directory for files and displays each one that matches the word in | |
| 203 front of the cursor. | |
| 204 Suppose, for example, that you have the following files in the current | |
| 205 directory: | |
| 206 | |
| 207 main.c sub_count.c sub_done.c sub_exit.c | |
| 208 | |
| 209 Now enter Insert mode and start typing: | |
| 210 | |
| 211 The exit code is in the file sub ~ | |
| 212 | |
| 213 At this point, you enter the command CTRL-X CTRL-F. Vim now completes the | |
| 214 current word "sub" by looking at the files in the current directory. The | |
| 215 first match is sub_count.c. This is not the one you want, so you match the | |
| 216 next file by typing CTRL-N. This match is sub_done.c. Typing CTRL-N again | |
| 217 takes you to sub_exit.c. The results: | |
| 218 | |
| 219 The exit code is in the file sub_exit.c ~ | |
| 220 | |
| 221 If the file name starts with / (Unix) or C:\ (MS-Windows) you can find all | |
| 222 files in the file system. For example, type "/u" and CTRL-X CTRL-F. This | |
| 223 will match "/usr" (this is on Unix): | |
| 224 | |
| 225 the file is found in /usr/ ~ | |
| 226 | |
| 227 If you now press CTRL-N you go back to "/u". Instead, to accept the "/usr/" | |
| 228 and go one directory level deeper, use CTRL-X CTRL-F again: | |
| 229 | |
| 230 the file is found in /usr/X11R6/ ~ | |
| 231 | |
| 232 The results depend on what is found in your file system, of course. The | |
| 233 matches are sorted alphabetically. | |
| 234 | |
| 819 | 235 |
| 236 COMPLETING IN SOURCE CODE | |
| 237 | |
| 238 Source code files are well structured. That makes it possible to do | |
| 239 completion in an intelligent way. In Vim this is called Omni completion. In | |
| 240 some other editors it's called intellisense, but that is a trademark. | |
| 241 | |
| 242 The key to Omni completion is CTRL-X CTRL-O. Obviously the O stands for Omni | |
| 243 here, so that you can remember it easier. Let's use an example for editing C | |
| 244 source: | |
| 245 | |
| 246 { ~ | |
| 247 struct foo *p; ~ | |
| 248 p-> ~ | |
| 249 | |
| 250 The cursor is after "p->". Now type CTRL-X CTRL-O. Vim will offer you a list | |
| 251 of alternatives, which are the items that "struct foo" contains. That is | |
| 252 quite different from using CTRL-P, which would complete any word, while only | |
| 253 members of "struct foo" are valid here. | |
| 254 | |
| 1122 | 255 For Omni completion to work you may need to do some setup. At least make sure |
| 256 filetype plugins are enabled. Your vimrc file should contain a line like | |
| 257 this: > | |
| 258 filetype plugin on | |
| 259 Or: > | |
| 260 filetype plugin indent on | |
| 261 | |
| 262 For C code you need to create a tags file and set the 'tags' option. That is | |
| 263 explained |ft-c-omni|. For other filetypes you may need to do something | |
| 264 similar, look below |compl-omni-filetypes|. It only works for specific | |
| 265 filetypes. Check the value of the 'omnifunc' option to find out if it would | |
| 266 work. | |
| 819 | 267 |
| 7 | 268 ============================================================================== |
| 269 *24.4* Repeating an insert | |
| 270 | |
| 271 If you press CTRL-A, the editor inserts the text you typed the last time you | |
| 272 were in Insert mode. | |
| 273 Assume, for example, that you have a file that begins with the following: | |
| 274 | |
| 275 "file.h" ~ | |
| 276 /* Main program begins */ ~ | |
| 277 | |
| 278 You edit this file by inserting "#include " at the beginning of the first | |
| 279 line: | |
| 280 | |
| 281 #include "file.h" ~ | |
| 282 /* Main program begins */ ~ | |
| 283 | |
| 284 You go down to the beginning of the next line using the commands "j^". You | |
| 285 now start to insert a new "#include" line. So you type: > | |
| 286 | |
| 287 i CTRL-A | |
| 288 | |
| 289 The result is as follows: | |
| 290 | |
| 291 #include "file.h" ~ | |
| 292 #include /* Main program begins */ ~ | |
| 293 | |
| 294 The "#include " was inserted because CTRL-A inserts the text of the previous | |
| 295 insert. Now you type "main.h"<Enter> to finish the line: | |
| 296 | |
| 297 | |
| 298 #include "file.h" ~ | |
| 299 #include "main.h" ~ | |
| 300 /* Main program begins */ ~ | |
| 301 | |
| 302 The CTRL-@ command does a CTRL-A and then exits Insert mode. That's a quick | |
| 303 way of doing exactly the same insertion again. | |
| 304 | |
| 305 ============================================================================== | |
| 306 *24.5* Copying from another line | |
| 307 | |
| 308 The CTRL-Y command inserts the character above the cursor. This is useful | |
| 309 when you are duplicating a previous line. For example, you have this line of | |
| 310 C code: | |
| 311 | |
| 312 b_array[i]->s_next = a_array[i]->s_next; ~ | |
| 313 | |
| 314 Now you need to type the same line, but with "s_prev" instead of "s_next". | |
| 315 Start the new line, and press CTRL-Y 14 times, until you are at the "n" of | |
| 316 "next": | |
| 317 | |
| 318 b_array[i]->s_next = a_array[i]->s_next; ~ | |
| 319 b_array[i]->s_ ~ | |
| 320 | |
| 321 Now you type "prev": | |
| 322 | |
| 323 b_array[i]->s_next = a_array[i]->s_next; ~ | |
| 324 b_array[i]->s_prev ~ | |
| 325 | |
| 326 Continue pressing CTRL-Y until the following "next": | |
| 327 | |
| 328 b_array[i]->s_next = a_array[i]->s_next; ~ | |
| 329 b_array[i]->s_prev = a_array[i]->s_ ~ | |
| 330 | |
| 331 Now type "prev;" to finish it off. | |
| 332 | |
| 333 The CTRL-E command acts like CTRL-Y except it inserts the character below the | |
| 334 cursor. | |
| 335 | |
| 336 ============================================================================== | |
| 337 *24.6* Inserting a register | |
| 338 | |
| 339 The command CTRL-R {register} inserts the contents of the register. This is | |
| 340 useful to avoid having to type a long word. For example, you need to type | |
| 341 this: | |
| 342 | |
| 343 r = VeryLongFunction(a) + VeryLongFunction(b) + VeryLongFunction(c) ~ | |
| 344 | |
| 345 The function name is defined in a different file. Edit that file and move the | |
| 346 cursor on top of the function name there, and yank it into register v: > | |
| 347 | |
| 348 "vyiw | |
| 349 | |
| 350 "v is the register specification, "yiw" is yank-inner-word. Now edit the file | |
| 351 where the new line is to be inserted, and type the first letters: | |
| 352 | |
| 353 r = ~ | |
| 354 | |
| 355 Now use CTRL-R v to insert the function name: | |
| 356 | |
| 357 r = VeryLongFunction ~ | |
| 358 | |
| 359 You continue to type the characters in between the function name, and use | |
| 360 CTRL-R v two times more. | |
| 361 You could have done the same with completion. Using a register is useful | |
| 362 when there are many words that start with the same characters. | |
| 363 | |
| 364 If the register contains characters such as <BS> or other special characters, | |
| 365 they are interpreted as if they had been typed from the keyboard. If you do | |
| 366 not want this to happen (you really want the <BS> to be inserted in the text), | |
| 367 use the command CTRL-R CTRL-R {register}. | |
| 368 | |
| 369 ============================================================================== | |
| 370 *24.7* Abbreviations | |
| 371 | |
| 372 An abbreviation is a short word that takes the place of a long one. For | |
| 373 example, "ad" stands for "advertisement". Vim enables you to type an | |
| 374 abbreviation and then will automatically expand it for you. | |
| 375 To tell Vim to expand "ad" into "advertisement" every time you insert it, | |
| 376 use the following command: > | |
| 377 | |
| 378 :iabbrev ad advertisement | |
| 379 | |
| 380 Now, when you type "ad", the whole word "advertisement" will be inserted into | |
| 381 the text. This is triggered by typing a character that can't be part of a | |
| 382 word, for example a space: | |
| 383 | |
| 384 What Is Entered What You See | |
| 385 I saw the a I saw the a ~ | |
| 386 I saw the ad I saw the ad ~ | |
| 387 I saw the ad<Space> I saw the advertisement<Space> ~ | |
| 388 | |
| 389 The expansion doesn't happen when typing just "ad". That allows you to type a | |
| 390 word like "add", which will not get expanded. Only whole words are checked | |
| 391 for abbreviations. | |
| 392 | |
| 393 | |
| 394 ABBREVIATING SEVERAL WORDS | |
| 395 | |
| 396 It is possible to define an abbreviation that results in multiple words. For | |
| 397 example, to define "JB" as "Jack Benny", use the following command: > | |
| 398 | |
| 399 :iabbrev JB Jack Benny | |
| 400 | |
| 401 As a programmer, I use two rather unusual abbreviations: > | |
| 402 | |
| 403 :iabbrev #b /**************************************** | |
| 404 :iabbrev #e <Space>****************************************/ | |
| 405 | |
| 406 These are used for creating boxed comments. The comment starts with #b, which | |
| 407 draws the top line. I then type the comment text and use #e to draw the | |
| 408 bottom line. | |
| 409 Notice that the #e abbreviation begins with a space. In other words, the | |
| 410 first two characters are space-star. Usually Vim ignores spaces between the | |
| 411 abbreviation and the expansion. To avoid that problem, I spell space as seven | |
| 412 characters: <, S, p, a, c, e, >. | |
| 413 | |
| 414 Note: | |
| 415 ":iabbrev" is a long word to type. ":iab" works just as well. | |
| 416 That's abbreviating the abbreviate command! | |
| 417 | |
| 418 | |
| 419 FIXING TYPING MISTAKES | |
| 420 | |
| 421 It's very common to make the same typing mistake every time. For example, | |
| 422 typing "teh" instead of "the". You can fix this with an abbreviation: > | |
| 423 | |
| 424 :abbreviate teh the | |
| 425 | |
| 426 You can add a whole list of these. Add one each time you discover a common | |
| 427 mistake. | |
| 428 | |
| 429 | |
| 430 LISTING ABBREVIATIONS | |
| 431 | |
| 432 The ":abbreviate" command lists the abbreviations: | |
| 433 | |
| 434 :abbreviate | |
| 435 i #e ****************************************/ | |
| 436 i #b /**************************************** | |
| 437 i JB Jack Benny | |
| 438 i ad advertisement | |
| 439 ! teh the | |
| 440 | |
| 441 The "i" in the first column indicates Insert mode. These abbreviations are | |
| 442 only active in Insert mode. Other possible characters are: | |
| 443 | |
| 444 c Command-line mode :cabbrev | |
| 445 ! both Insert and Command-line mode :abbreviate | |
| 446 | |
| 447 Since abbreviations are not often useful in Command-line mode, you will mostly | |
| 448 use the ":iabbrev" command. That avoids, for example, that "ad" gets expanded | |
| 449 when typing a command like: > | |
| 450 | |
| 451 :edit ad | |
| 452 | |
| 453 | |
| 454 DELETING ABBREVIATIONS | |
| 455 | |
| 456 To get rid of an abbreviation, use the ":unabbreviate" command. Suppose you | |
| 457 have the following abbreviation: > | |
| 458 | |
| 459 :abbreviate @f fresh | |
| 460 | |
| 461 You can remove it with this command: > | |
| 462 | |
| 463 :unabbreviate @f | |
| 464 | |
| 465 While you type this, you will notice that @f is expanded to "fresh". Don't | |
| 466 worry about this, Vim understands it anyway (except when you have an | |
| 467 abbreviation for "fresh", but that's very unlikely). | |
| 468 To remove all the abbreviations: > | |
| 469 | |
| 470 :abclear | |
| 471 | |
| 472 ":unabbreviate" and ":abclear" also come in the variants for Insert mode | |
| 473 (":iunabbreviate and ":iabclear") and Command-line mode (":cunabbreviate" and | |
| 474 ":cabclear"). | |
| 475 | |
| 476 | |
| 477 REMAPPING ABBREVIATIONS | |
| 478 | |
| 479 There is one thing to watch out for when defining an abbreviation: The | |
| 480 resulting string should not be mapped. For example: > | |
| 481 | |
| 482 :abbreviate @a adder | |
| 483 :imap dd disk-door | |
| 484 | |
| 485 When you now type @a, you will get "adisk-doorer". That's not what you want. | |
| 486 To avoid this, use the ":noreabbrev" command. It does the same as | |
| 487 ":abbreviate", but avoids that the resulting string is used for mappings: > | |
| 488 | |
| 489 :noreabbrev @a adder | |
| 490 | |
| 491 Fortunately, it's unlikely that the result of an abbreviation is mapped. | |
| 492 | |
| 493 ============================================================================== | |
| 494 *24.8* Entering special characters | |
| 495 | |
| 496 The CTRL-V command is used to insert the next character literally. In other | |
| 497 words, any special meaning the character has, it will be ignored. For | |
| 498 example: > | |
| 499 | |
| 500 CTRL-V <Esc> | |
| 501 | |
| 502 Inserts an escape character. Thus you don't leave Insert mode. (Don't type | |
| 503 the space after CTRL-V, it's only to make this easier to read). | |
| 504 | |
| 505 Note: | |
| 506 On MS-Windows CTRL-V is used to paste text. Use CTRL-Q instead of | |
| 507 CTRL-V. On Unix, on the other hand, CTRL-Q does not work on some | |
| 508 terminals, because it has a special meaning. | |
| 509 | |
| 510 You can also use the command CTRL-V {digits} to insert a character with the | |
| 511 decimal number {digits}. For example, the character number 127 is the <Del> | |
| 512 character (but not necessarily the <Del> key!). To insert <Del> type: > | |
| 513 | |
| 514 CTRL-V 127 | |
| 515 | |
| 516 You can enter characters up to 255 this way. When you type fewer than two | |
| 517 digits, a non-digit will terminate the command. To avoid the need of typing a | |
| 518 non-digit, prepend one or two zeros to make three digits. | |
| 519 All the next commands insert a <Tab> and then a dot: | |
| 520 | |
| 521 CTRL-V 9. | |
| 522 CTRL-V 09. | |
| 523 CTRL-V 009. | |
| 524 | |
| 525 To enter a character in hexadecimal, use an "x" after the CTRL-V: > | |
| 526 | |
| 527 CTRL-V x7f | |
| 528 | |
| 529 This also goes up to character 255 (CTRL-V xff). You can use "o" to type a | |
| 530 character as an octal number and two more methods allow you to type up to | |
| 531 a 16 bit and a 32 bit number (e.g., for a Unicode character): > | |
| 532 | |
| 533 CTRL-V o123 | |
| 534 CTRL-V u1234 | |
| 535 CTRL-V U12345678 | |
| 536 | |
| 537 ============================================================================== | |
| 538 *24.9* Digraphs | |
| 539 | |
| 540 Some characters are not on the keyboard. For example, the copyright character | |
|
13482
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
541 (©). To type these characters in Vim, you use digraphs, where two characters |
|
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
542 represent one. To enter a ©, for example, you press three keys: > |
| 7 | 543 |
| 544 CTRL-K Co | |
| 545 | |
| 546 To find out what digraphs are available, use the following command: > | |
| 547 | |
| 548 :digraphs | |
| 549 | |
| 550 Vim will display the digraph table. Here are three lines of it: | |
| 551 | |
|
13482
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
552 AC ~_ 159 NS | 160 !I ¡ 161 Ct ¢ 162 Pd £ 163 Cu ¤ 164 Ye ¥ 165 ~ |
|
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
553 BB ¦ 166 SE § 167 ': ¨ 168 Co © 169 -a ª 170 << « 171 NO ¬ 172 ~ |
|
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
554 -- 173 Rg ® 174 'm ¯ 175 DG ° 176 +- ± 177 2S ² 178 3S ³ 179 ~ |
| 7 | 555 |
| 556 This shows, for example, that the digraph you get by typing CTRL-K Pd is the | |
|
13482
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
557 character (£). This is character number 163 (decimal). |
| 7 | 558 Pd is short for Pound. Most digraphs are selected to give you a hint about |
| 559 the character they will produce. If you look through the list you will | |
| 560 understand the logic. | |
| 561 You can exchange the first and second character, if there is no digraph for | |
| 562 that combination. Thus CTRL-K dP also works. Since there is no digraph for | |
| 563 "dP" Vim will also search for a "Pd" digraph. | |
| 564 | |
| 565 Note: | |
| 566 The digraphs depend on the character set that Vim assumes you are | |
| 18972 | 567 using. Always use ":digraphs" to find out which digraphs are currently |
| 568 available. | |
| 7 | 569 |
| 570 You can define your own digraphs. Example: > | |
| 571 | |
|
13482
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
572 :digraph a" ä |
| 7 | 573 |
|
13482
9eebe457eb3c
Update runtime files. Convert a couple of help files to utf-8.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
574 This defines that CTRL-K a" inserts an ä character. You can also specify the |
| 7 | 575 character with a decimal number. This defines the same digraph: > |
| 576 | |
| 577 :digraph a" 228 | |
| 578 | |
| 579 More information about digraphs here: |digraphs| | |
| 580 Another way to insert special characters is with a keymap. More about that | |
| 581 here: |45.5| | |
| 582 | |
| 583 ============================================================================== | |
| 584 *24.10* Normal mode commands | |
| 585 | |
| 586 Insert mode offers a limited number of commands. In Normal mode you have many | |
| 587 more. When you want to use one, you usually leave Insert mode with <Esc>, | |
| 588 execute the Normal mode command, and re-enter Insert mode with "i" or "a". | |
| 589 There is a quicker way. With CTRL-O {command} you can execute any Normal | |
| 590 mode command from Insert mode. For example, to delete from the cursor to the | |
| 591 end of the line: > | |
| 592 | |
| 593 CTRL-O D | |
| 594 | |
| 595 You can execute only one Normal mode command this way. But you can specify a | |
| 596 register or a count. A more complicated example: > | |
| 597 | |
| 598 CTRL-O "g3dw | |
| 599 | |
| 600 This deletes up to the third word into register g. | |
| 601 | |
| 602 ============================================================================== | |
| 603 | |
| 604 Next chapter: |usr_25.txt| Editing formatted text | |
| 605 | |
| 14519 | 606 Copyright: see |manual-copyright| vim:tw=78:ts=8:noet:ft=help:norl: |