![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to teach-jove CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc|
Return to teach-jove CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc |
1.1 root 1: J O V E T U T O R I A L
2:
3: Welcome to JOVE - an advanced, easy-to-use, user-friendly environment
4: for editing text, programs or anything else you may like to type.
5:
6: JOVE commands generally involve the CONTROL key (sometimes labelled
7: CTRL or CTL) or the META key (generally labelled ESCAPE). Rather than
8: write out META or CONTROL each time we want you to prefix a character,
9: we'll use the following abbreviations:
10:
11: C-<chr> means hold the CONTROL key while typing the character <chr>
12: Thus, C-F would be: hold the CONTROL key and type F.
13: M-<chr> means type the META (ESCAPE) key and release it, then type
14: the character <chr>. The <chr> can be upper or lower case
15: and it will have the same meaning.
16:
17: Important note: if you must exit at some point, type C-X C-C.
18: The characters ">>" at the left margin indicate directions for you to
19: try using a command. For instance:
20:
21: >> Now type C-V (View next screen) to move to the next screen.
22: (go ahead, do it by depressing the control key and V together).
23: From now on, you'll be expected to do this whenever you finish
24: reading the screen.
25:
26: Note that there is an overlap when going from screen to screen; this
27: provides some continuity when moving through the file.
28:
29: The first thing that you need to know is how to move around from
30: place to place in the file. You already know how to move forward a
31: screen, with C-V. To move backwards a screen, type M-V (depress the
32: META key and type V, or type <ESC>V if you don't have a META or EDIT
33: key).
34:
35: >> Try typing M-V and then C-V to move back and forth a few times.
36:
37:
38: SUMMARY
39: -------
40:
41: The following commands are useful for viewing screenfuls:
42:
43: C-V Move forward one screenful
44: M-V Move backward one screenful
45: C-L Center the current line--clear screen and redisplay
46: everything if current line is already at center.
47:
48: >> find the cursor and remember what text is near it.
49: Then type a C-L.
50: Find the cursor again and see what text is near it now.
51:
52:
53: BASIC CURSOR CONTROL
54: --------------------
55:
56: Getting from screenful to screenful is useful, but how do you
57: reposition yourself within a given screen to a specific place? There
58: are several ways you can do this. One way (not the best, but the most
59: basic) is to use the commands previous, backward, forward and next.
60: As you can imagine these commands (which are given to JOVE as C-P,
61: C-B, C-F, and C-N respectively) move the cursor from where it
62: currently is to a new place in the given direction. Here, in a more
63: graphical form are the commands:
64:
65: Previous line, C-P
66: :
67: :
68: Backward, C-B .... Current cursor position .... Forward, C-F
69: :
70: :
71: Next line, C-N
72:
73: You'll probably find it easy to think of these by letter. P for
74: previous, N for next, B for backward and F for forward. These are the
75: basic cursor positioning commands and you'll be using them ALL the
76: time so it would be of great benefit if you learn them now.
77:
78: >> Do a few C-N's to bring the cursor down to this line.
79:
80: >> Move into the line with C-F's and then up with several C-P's. See
81: what C-P does when the cursor is in the middle of the line.
82:
83: Lines are separated by a single Linefeed character, which is what Unix
84: calls a Newline.
85:
86: >> Try to C-B at the beginning of a line. Do a few more C-B's.
87: Then do C-F's back to the end of the line and beyond.
88:
89: When you go off the top or bottom of the screen, the text beyond the
90: edge is shifted onto the screen so that your instructions can be
91: carried out while keeping the cursor on the screen.
92:
93: >> Try to move the cursor off the bottom of the screen with C-N and
94: see what happens.
95:
96: If moving by characters is too slow, you can move by words. M-F
97: (Meta-F) moves forward a word and M-B moves back a word.
98:
99: >> Type a few M-F's and M-B's. Intersperse them with C-F's and C-B's.
100:
101: Notice the parallel between C-F and C-B on the one hand, and M-F and
102: M-B on the other hand. Very often Meta characters are used for
103: operations related to English text whereas Control characters operate
104: on the basic textual units that are independent of what you are
105: editing (characters, lines, etc). There is a similar parallel between
106: lines and sentences: C-A and C-E move to the beginning or end of a
107: line, and M-A and M-E move to the beginning or end of a sentence.
108:
109: >> Try a couple of C-A's, and then a couple of C-E's.
110: Try a couple of M-A's, and then a couple of M-E's.
111:
112: See how repeated C-A's do nothing, but repeated M-A's keep moving
113: farther. Do you think that this is right?
114:
115: Two other simple cursor motion commands are M-< (Meta Less-than),
116: which moves to the beginning of the file, and M-> (Meta Greater-than),
117: which moves to the end of the file. You probably don't need to try
118: them, since finding this spot again will be boring. If you need the
119: shift key to type a "<", then you must also use the shift key to type
120: M-<. Otherwise, you would be typing M-, .
121:
122: The location of the cursor in the text is also called "point". To
123: paraphrase, the cursor shows on the screen where point is located in
124: the text.
125:
126: Here is a summary of simple moving operations including the word and
127: sentence moving commands:
128:
129: C-F Move forward a character
130: C-B Move backward a character
131:
132: M-F Move forward a word
133: M-B Move backward a word
134:
135: C-N Move to next line
136: C-P Move to previous line
137:
138: C-A Move to beginning of line
139: C-E Move to end of line
140:
141: M-A Move back to beginning of sentence
142: M-E Move forward to end of sentence
143:
144: M-< Go to beginning of file
145: M-> Go to end of file
146:
147: >> Try all of these commands now a few times for practice. Since the
148: last two will take you away from this screen, you can come back
149: here with the command C-X C-X (which will be explained later).
150: These are the most often used commands.
151:
152: Like all other commands in JOVE, these commands can be given arguments
153: which cause them to be executed repeatedly. The way you give a
154: command a repeat count is by typing META and then the digits before
155: you type the command. (Remember META is ususally called ESCAPE)
156:
157: For instance, META 8 C-F moves forward eight characters.
158:
159: >> Try giving a suitable argument to C-N or C-P to come as close
160: as you can to this line in one jump.
161:
162: The only apparent exception to this is the screen moving commands, C-V
163: and M-V. When given an argument, they scroll the screen up or down by
164: that many lines, rather than screenfuls. This proves to be much more
165: useful.
166:
167: >> Try typing M-8 C-V now.
168:
169: Did it scroll the screen up by 8 lines? If you would like to scroll
170: it down you can give an argument to M-V.
171:
172:
173:
174: THE UNIVERSAL ARGUMENT
175: ----------------------
176: Almost every command in JOVE takes a so-called Universal Argument.
177: This argument, although it is interpreted differently in some cases,
178: usually means REPEAT. One important exception to this is with the screen
179: moving commands. In this case, the number refers to the number of LINES
180: to scroll, not the number of screens.
181:
182: The way you give a command a universal argument is by typing ESC and
183: then the number. For example, ESC 10 C-F would move you forward ten
184: characters.
185:
186: >>> Try giving a suitable argument to C-N or C-P to come as close as you
187: can to this line in one jump. Then try giving the same command,
188: except make the number negative.
189:
190: Another count-giving command is C-U. This command, when you first type
191: it, gives you an argument of 4 (four). If you type C-U C-U, you will get
192: an argument of 16. Each time C-U is typed, the argument is multiplied by
193: four.
194:
195: >>> Try typing ESC 8 C-V now.
196:
197: THE GOTO COMMAND
198: ----------------
199: Now that we've learned about the universal argument, we can introduce
200: another cursor positioning command, the command to move to a specific
201: line. This command is given by giving a line number via ESC, and then
202: typing M-G.
203:
204: >>> Try using the M-< and M-> commands to move to the beginning and the
205: end of the file. Then come back here using the M-G command (this is
206: line 206, so you'd type ESC 206 M-G.)
207:
208: QUITTING FROM COMMANDS
209: ----------------------
210:
211: The character in JOVE used to quit out of all commands which request
212: input is C-G. For example, you can use C-G to discard a numeric
213: argument or the beginning of a command that you don't want to finish.
214:
215: >> Type M-100 to make a numeric arg of 100, then type C-G. Now type
216: C-F. How many characters does it move? If you have typed an <ESC>
217: by mistake, you can get rid of it with a C-G.
218:
219:
220: ERRORS
221: ------
222:
223: Sometimes you may do something which JOVE doesn't allow. If it is
224: something simple, such as typing a control key sequence which is not
225: associated with any command, JOVE will just beep at you. Otherwise,
226: JOVE will also display an informative error message at the bottom of
227: the screen.
228:
229: Some versions of JOVE do not have all the features described in this
230: tutorial implemented yet. If you come across such an unimplemented
231: feature, you may get an error message when you try to use it. Just
232: proceed on to the next section of the tutorial.
233:
234:
235: INSERTING AND DELETING
236: ----------------------
237:
238: If you want to type text, just do it. Characters which you can see,
239: such as A, 7, *, etc. are taken by JOVE as text and inserted
240: immediately. Type <Return> (the carriage-return key) to insert a line
241: separator.
242:
243: You can delete the last character you typed by typing <Delete>.
244: <Delete> is a key on the keyboard, which may be labeled "Rubout"
245: instead of "Delete" on some terminals. More generally, <Delete>
246: deletes the character immediately before the current cursor position.
247:
248: >> Do this now, type a few characters and then delete them by typing
249: <Delete> a few times. Don't worry about this file being changed;
250: you won't affect the master tutorial. This is just a copy of it.
251:
252: >> Now start typing text until you reach the right margin, and keep
253: typing. When a line of text gets too big for one line on the
254: screen, the line of text is "continued" off the edge of the screen
255: The exclamation mark at the right margin indicates a line which has
256: been continued. The line will slide over if you move off the edge
257: on either side.
258:
259: >> The following line actually goes off the edge. Trying typing enough
260: C-F's that you move off the right hand end of this line.... This is a long line of text that the JOVE editor extends to the right.
261:
262: >> Use <Delete>s to delete the text until the line fits on one screen
263: line again. The continuation "!" will go away.
264:
265: >> Move the cursor to the beginning of a line and type <Delete>. This
266: deletes the line separator before the line and merges the line onto
267: the previous line. The resulting line may be too long to fit, in
268: which case it has a continuation indication.
269:
270: >> Type <Return> to insert the separator again.
271:
272: Remember that most JOVE commands can be given a repeat count; Note
273: that this includes characters which insert themselves.
274:
275: >> Try that now -- type META 8 * and see what happens.
276:
277: If you want to create a blank line in between two lines, move to the
278: second of the two lines and type C-O.
279:
280: >> Try moving to a line and typing C-O now.
281:
282: You've now learned the most basic way of typing something in JOVE and
283: correcting errors. You can delete by words or lines as well. Here is
284: a summary of the delete operations:
285:
286: <Delete> delete the character just before the cursor
287: C-D delete the next character after the cursor
288:
289: M-<Delete> kill the word immediately before the cursor
290: M-D kill the next word after the cursor
291:
292: C-K kill from the cursor position to end of line
293: M-K kill to the end of the current sentence
294:
295: Notice that <Delete> and C-D vs M-<Delete> and M-D extend the parallel
296: started by C-F and M-F (well, <Delete> isn't really a control
297: character, but let's not worry about that). C-K and M-K are like C-E
298: and M-E, sort of, in that lines are opposite sentences.
299:
300: Now suppose you kill something, and then you decide that you want to
301: get it back? Well, whenever you kill something bigger than a
302: character, JOVE saves it for you. To yank it back, use C-Y. Note
303: that you don't have to be in the same place to do C-Y; This is a good
304: way to move text around. Also note that the difference between
305: "Killing" and "Deleting" something is that "Killed" things can be
306: yanked back, and "Deleted" things cannot. Generally, the commands
307: that can destroy a lot of text save it, while the ones that attack
308: only one character, or nothing but blank lines and spaces, do not save.
309:
310: For instance, type C-N a couple times to postion the cursor at some
311: line on this screen.
312:
313: >> Do this now, move the cursor and kill that line with C-K.
314:
315: Note that a single C-K kills the contents of the line, and a second
316: C-K kills the line itself, and make all the other lines move up. If
317: you give C-K a repeat count, it kills that many lines AND their
318: contents.
319:
320: The text that has just disappeared is saved so that you can retrieve
321: it. To retrieve the last killed text and put it where the cursor
322: currently is, type C-Y.
323:
324: >> Try it; type C-Y to yank the text back.
325:
326: Think of C-Y as if you were yanking something back that someone took
327: away from you. Notice that if you do several C-K's in a row the text
328: that is killed is all saved together so that one C-Y will yank all of
329: the lines.
330:
331: >> Do this now, type C-K several times.
332:
333: Now to retrieve that killed text:
334:
335: >> Type C-Y. Then move the cursor down a few lines and type C-Y
336: again. You now see how to copy some text.
337:
338: What do you do if you have some text you want to yank back, and then
339: you kill something else? C-Y would yank the more recent kill. But
340: the previous text is not lost. You can get back to it using the M-Y
341: command. After you have done C-Y to get the most recent kill, typing
342: M-Y replaces that yanked text with the previous kill. Typing M-Y
343: again and again brings in earlier and earlier kills. When you have
344: reached the text you are looking for, you can just go away and leave
345: it there. If you M-Y enough times, you come back to the starting
346: point (the most recent kill).
347:
348: >> Kill a line, move around, kill another line. Then do C-Y to get
349: back the second killed line. Then do M-Y and it will be replaced
350: by the first killed line. Do more M-Y's and see what you get.
351: Keep doing them until the second kill line comes back, and then a
352: few more. If you like, you can try giving M-Y positive and negative
353: arguments.
354:
355:
356: FILES
357: -----
358:
359: In order to make the text you edit permanent, you must put it in a
360: file. Otherwise, it will go away when your invocation of JOVE goes
361: away. While you are editing a file in JOVE, your changes are actually
362: being made to a private "scratch" copy of the file. However, the
363: changes still don't become permanent until you "save" the file. This
364: is so you can have control to avoid leaving a half-changed file around
365: when you don't want to.
366:
367: If you look near the botton of the screen you will see a line that
368: looks like this:
369: JOVE (Text) Buffer: teach-jove "teach-jove" *
370: "teach-jove" is the name of the file you are editing. This is the name
371: of your own temporary copy of the text of the JOVE tutorial; the file
372: you are now editing. Whatever file you edit, that file's name will
373: appear in that precise spot.
374:
375: The commands for finding and saving files are unlike the other
376: commands you have learned in that they consist of two characters.
377: They both start with the character Control-X. There is a whole series
378: of commands that start with Control-X; many of them have to do with
379: files, buffers, and related things, and all of them consist of
380: Control-X followed by some other character. As with M- the character
381: interpreted the same regardless of case.
382:
383: Another thing about the command for finding a file is that you have to
384: say what file name you want. We say the command "reads an argument
385: from the terminal" (in this case, the argument is the name of the
386: file). After you type the command
387:
388: C-X C-F Find a file
389:
390: JOVE will ask you for the file name. You should end the name with
391: the Return key. After this command, you will see the contents of the
392: file in your JOVE. You can edit the contents. When you wish to make
393: the changes permanent, issue the command
394:
395: C-X C-S Save the file
396:
397: Warning: on many systems JOVE will not be able to process the key C-S.
398: In place of C-S, you should type C-\. It is possible to make C-S work
399: but C-\ is guaranteed always to work in place of C-S.
400:
401: The old version of the file will be replaced. When the operation is
402: finished, JOVE prints the name and number of lines and characters
403: saved.
404:
405: If you forget to save and then edit a different file, JOVE will remind
406: you that you made changes that have not been saved and then ask you
407: whether you really want to quit. (If you don't save them, they will
408: be thrown away. That might be what you want!) You should answer with
409: a "Y" to throw the changes away or "N" to abort quitting so you can
410: then save the changes.
411:
412: To make a new file, just edit it "as if" it already existed. Then
413: start typing in the text. When you ask to "save" the file, JOVE will
414: really create the file with the text that you have inserted. From
415: then on, you can consider yourself to be editing an already existing
416: file.
417:
418: It is not easy for you to try out editing a file and continue with the
419: tutorial. But you can always come back into the tutorial by starting
420: it over and skipping forward. So, when you feel ready, you should try
421: editing a file named "FOO", putting some text in it, and saving it;
422: then exit from JOVE and look at the file to be sure that it worked.
423:
424: CONCLUSION OF PART ONE
425: ----------------------
426: This is the end of the first part of this tutorial. You now know
427: enough to edit a file with JOVE, and save your work. The second part of
428: this tutorial, which starts with the next section, discusses searching,
429: replacing, word processing, and other modes of JOVE. You may wish to
430: stop here and practice for awhile before you continue.
431:
432:
433: EXTENDING THE COMMAND SET
434: -------------------------
435:
436: There are many, many more JOVE commands than could possibly be put on
437: all the control and meta characters. JOVE gets around this with the X
438: (eXtend) command. This comes in two flavors:
439:
440: C-X Character eXtend. Followed by one character.
441: M-X Named command eXtend. Followed by a long name.
442:
443: These are commands that are generally useful but used less than the
444: commands you have already learned about. You have already seen two of
445: them: the file commands C-X C-F to Find and C-X C-S to Save. Another
446: example is the command to tell JOVE that you'd like to stop editing.
447: The command to do this is C-X C-C.
448:
449: There are many C-X commands. The ones you need immediately are:
450:
451: C-X C-V Visit file.
452: C-X C-S Save file.
453: C-X C-C Quit JOVE. This does not save your files auto-
454: matically, though if your files have been modi-
455: fied, JOVE asks if you really want to quit. The
456: standard way to save and exit is C-X C-S C-X C-C.
457:
458: Named eXtended commands are commands which are used even less
459: frequently, or commands which are used only in certain modes. These
460: commands are usually called "commands". An example is the command
461: "apropos", which prompts for a keyword and then gives the names of all
462: the commands that apropos for that keyword. When you type M-X, JOVE
463: prompts you at the bottom of the screen with ":" and you should type
464: the name of the command you wish to call; in this case, "apropos".
465: Just type "apr<Space>" and JOVE will complete the name. JOVE will ask
466: you for a keyword or phrase and you type the string that you want ask
467: about.
468:
469: >> Try typing M-X, followed by "apropos" or "apr" and then Return.
470: Then try typing "file" followed by a Return.
471:
472:
473: MODE LINE
474: ---------
475:
476: If JOVE sees that you are typing commands slowly it shows them to you
477: at the bottom of the screen in an area called the echo area. The echo
478: area contains the bottom line of the screen. The line immediately above
479: them is called the MODE LINE. The mode line says something like
480:
481: JOVE (Text) Buffer: [buffername] "filename" *
482:
483: This is a very useful "information" line.
484:
485: The buffername is the name JOVE gave to the buffer, and it is usually
486: related to the filename. You already know what the filename means --
487: it is the file you have edited.
488:
489: The star means that you have made changes to the text. Right after
490: you visit or save a file, there is no star.
491:
492: The part of the mode line inside the parentheses is to tell you what
493: modes you are in. The default mode is Text which is what you are in
494: now. It is an example of a "major mode". There are several major
495: modes in JOVE for editing different languages and text, such as C
496: mode, Lisp mode, Text mode, etc. At any time one and only one major
497: mode is active, and its two-letter code can always be found in the
498: mode line just where "Text" is now. Each major mode makes a few
499: commands behave differently. For example, what JOVE considers as part
500: of a valid expression or an identifier differs from one major mode to
501: another, since each programming language has a different idea of what
502: is a legal identifier.
503:
504: Major modes are called major because there are also minor modes. They
505: are called minor because they aren't alternatives to the major modes,
506: just minor modifications of them. Each minor mode can be turned on or
507: off by itself, regardless of what major mode you are in, and
508: regardless of the other minor modes. So you can use no minor modes,
509: or one minor mode, or any combination of several minor modes.
510:
511: One minor mode which is very useful, especially for editing English
512: text, is "Auto Fill" mode. When this mode is on, JOVE breaks the line
513: in between words automatically whenever the line gets too long. You
514: can turn this mode on by doing M-X auto-fill-mode<Return>. When the
515: mode is on, you can turn it off by doing M-X auto-fill-mode<Return>--
516: it toggles.
517:
518: >> Type "M-X auto-fill-mode<Return>" now. Then insert a line with a
519: bunch of words over again until you see it divide into two lines.
520: You must put in spaces between them because Auto Fill breaks lines
521: only at spaces. Notice that "Fill" (the code for Auto Fill) appears
522: in the mode line after "Text" to indicate that you are in Text Fill
523: mode.
524:
525: The margin is usually set at 78 characters, but you can change it with
526: the set command. The margin is kept in a variable just like the mode
527: values.
528:
529: >> Type "M-X set right-margin 20", then type in some text and see
530: JOVE fill lines of 20 characters with it. Then set the margin
531: back to 72 using M-X set again.
532:
533:
534: SEARCHING
535: ---------
536:
537: JOVE can do searches for strings (these are groups of contiguous
538: characters or words) either forward through the file or backward
539: through it. To search for the string means that you are trying to
540: find that string somewhere in the file. Remember to use C-\ where it
541: says C-S.
542:
543: >> Now type C-S to start a search. Type the word 'cursor', then
544: Return.
545:
546: >> Type C-S Return to find the next occurrence of "cursor".
547:
548: The C-S starts a search that looks for any occurrence of the search
549: string AFTER the current cursor position. But what if you want to
550: search for something earlier in the text? To do this one should type
551: C-R for reverse search. Everything that applies to C-S applies to C-R
552: except that the direction of the search is reversed.
553:
554:
555: REPLACING TEXT
556: --------------
557:
558: >> Move the cursor to the blank line two lines below this one.
559: Then type M-r changed<Return>altered<Return>.
560:
561: Notice how this line has changed: you've replaced the word
562: c-h-a-n-g-e-d with "altered" wherever it occurs after the cursor.
563:
564: The more customary command for replacing strings is the interactive
565: command query-replace-search, which has several options. In essence,
566: it shows each occurrence of the first string and asks you if you want to
567: replace it or not. You can also choose to edit around the string, or
568: go on and replace all occurrences without asking further.
569:
570: This is invoked with M-Q.. When you start up a Query Replace, it
571: will prompt you with "From" and "To", for what you want to change, and
572: what you want to change it to. JOVE will then move to the first
573: occurence of the "From", and wait for a character. You can type:
574:
575: <SPACE> Do the replacement, and move to next occurrence
576: of the "From" string.
577: <DEL> Skip the current "From" string and move to the
578: next one.
579: RETURN Exit the Query Replace now.
580: r Recursive Edit
581: p Replace all further occurences of the "From"
582: string, without asking.
583:
584: Recursive edit makes it possible to temporarily supend the Q-R-S, let the
585: user go off and do something, and then return to the search after the he
586: is done. The command exit-jove (C-X C-C) returns from the recursive-edit.
587:
588: GETTING MORE HELP
589: -----------------
590:
591: In this tutorial we have tried to supply just enough information to
592: get you started using JOVE. There is so much available in JOVE that
593: it would be impossible to explain it all here. However, you may want
594: to learn more about JOVE since it has numerous desirable features that
595: you don't know about yet. JOVE has a some internal documentation.
596:
597: The most basic HELP feature is the describe-key command which is
598: available by typing C-X ? and then a command character. JOVE prints
599: one line line on the bottom of the screen tell what command is bound to
600: that key. You can then get further information on that command
601: using...
602:
603: The describe-command command M-? will prompt for the name of a command
604: and print out the section from the manual about that command. When you
605: are finished reading it, type a Space or a C-G (quit) to bring your text
606: back on the screen.
607:
608: >> Type C-X ? Control-P. The message at the bottom of the screen should
609: be something like "C-P is bound to previous-line".
610:
611: Multi-character commands such as C-X C-C and <ESC>V are also allowed
612: after C-X ?.
613:
614: Now lets get more information about the previous-line command.
615:
616: >> Type M-? previous-line. When you are finished reading the
617: output, type a Space.
618:
619: The "name of the command" is important for people who are customizing
620: JOVE. It is what appears in the JOVE CHART as the documentation for
621: the command character.
622:
623: One other form of help is the "apropos" command. We have already tried
624: using this command in an earlier part of this tutorial, but it should
625: be mentioned again here. Apropos prompts for a word or phrase and
626: lists all the commands that contain that string. If you couldn't
627: remember the name of a certain command to read file, you could run the
628: apropos command with the keyword "file" and it would list all the
629: commands that contain "file". To run apropos you would type
630:
631: M-X apr<Space>file<Return>
632:
633: Finally, the full set of JOVE manuals are in five parts, and reside in
634: the directory /usr/src/local/jove/doc under the names jove.1 to jove.5.
635: These are in TROFF form, and the documents in /usr/src/local/jove/doc/docs
636: are in a form readable on the terminal or line-printer. Besides, someone
637: around you must have a printed version which you can borrow! There is also
638: a chart of JOVE commands, sorted by function, which is handy as a quick
639: reference.
640:
641: CONCLUSION OF PART TWO
642: ----------------------
643: This concludes section two of the JOVE tutorial. The rest of this
644: tutorial describes some of the very advanced features of JOVE, such as
645: editing more than one file at once, writing your own macros, windows, and
646: initialization files. Unless you're already somewhat familiar with
647: JOVE, you should probably wait a little while before starting the third
648: section.
649:
650: MARKS AND REGIONS
651: -----------------
652:
653: In general, a command which processes an arbitrary part of the buffer
654: must know where to start and where to stop. In JOVE, such commands
655: usually operate on the text between point (where the cursor is now) and
656: "the mark". This range of text is called "the region". To specify a
657: region, you set point to one end of it and mark at the other. It doesn't
658: matter which one is set first chronologically, or which one comes earlier
659: in the text. Here are some commands for setting the mark:
660:
661: C-@ Set the mark where point is.
662: C-<SPACE> The same.
663: C-X C-X Interchange mark and point.
664:
665: The most common way to set the mark is with the C-@ command or the
666: C-<SPACE> command. They set the mark where point is. Then you can move
667: point away, leaving the mark behind.
668:
669: Since terminals have only one cursor, there is no way for JOVE to
670: show you where the mark is located. You have to remember. The usual
671: solution to this problem is to set the mark and then use it soon, before
672: you forget where it is. But you can see where the mark is with the
673: command C-X C-X which puts the mark where point was and point where the
674: mark was. The extent of the region is unchanged, but the cursor and
675: point are now at the previous location of the mark.
676:
677: There are many, many commands which use regions (the area between the
678: point and the mark), which we have not mentioned here. They are all
679: similar to such things as "transpose paragraphs", etc., and can be found
680: in the wall chart.
681:
682: BUFFERS
683: -------
684: When editing a file, JOVE reads the file into a buffer. This is
685: where the modifcations are done, and when you save the file with C-X C-S,
686: the buffer is actually written out to the file. JOVE permits you to
687: have up to 100 buffers, so, in essence, you can edit up to 100 files at
688: the same time.
689:
690: If you want to list the buffers you have, use the C-X C-B command.
691: This will display a list of the buffers, their numbers and names, and
692: whether or not they've been modified.
693:
694: >>> Do this now, type C-X C-B. When you're done looking, type a <SPACE>.
695:
696: You probably noticed you only have one buffer, named "Main". If you
697: were editing more than one file, however, you would have more than one
698: buffer. There are two ways to edit more than one file. The first is to
699: call JOVE with more than one file on the command line. For example, the
700: command
701:
702: jove a b c
703:
704: would create three buffers (named Main, b, and c), each one containing
705: one file. The other way is to use the C-X C-F command (called Find
706: File). This command prompts you for a filename, and then reads that file
707: into a new buffer, and puts you into the new buffer.
708:
709: To change buffers, use the C-X B command. JOVE will prompt you for a
710: buffer name, and print a name in parentheses. If you just hit a carriage
711: return without typing a buffer name, you will go to the buffer named in
712: parentheses. Another way to change buffers is to give C-X B a NUMBER.
713: This goes to the buffer NUMBER, rather than using the buffer name.
714:
715: >>> Get a piece of paper, and write down the following commands. Then
716: run them, to get a feel for playing with buffers. BE SURE TO WRITE
717: THEM DOWN! We don't want to get you lost!
718:
719: C-X C-B
720: <SPACE>
721: C-X C-F (type "/etc/motd" to the prompt)
722: C-X C-B
723: <SPACE>
724: C-X B
725: <RETURN>
726:
727: Well, wasn't that fun? Now you know how to get another file into
728: another buffer, and then "bounce" back and forth. A nice feature about
729: editing more than one file is that you can transfer text from one file to
730: the other. Just kill it in one file, change buffers, and then put it
731: back with C-Y.
732:
733: WINDOWS
734: -------
735: What you see on your screen is a "window" into the buffer you are
736: editing. JOVE allows you to have more than one window on your screen, and
737: you can therefore look into two, or more buffers at once. You can also look at
738: different parts of the same file. The command C-X 2 splits your screen into
739: two windows, both looking into the same buffer. The command C-X 4 f will
740: display a specified file in the other window, C-X 4 b will display a specified
741: buffer in the other window, C-X n moves to the next window on the screen,
742: while C-X p moves to the previous window.
743:
744: >>> Try the command C-X 2, which splits the screen into two windows, and
745: displays the same buffer in both. You'll notice that you are in the new
746: window. Try some commmands in this window, like C-V, or M-V, to move
747: around in the file. Observe that the other window doesn't change its
748: position relative to the buffer. This gives you a way of looking at two
749: parts of the same file.
750:
751: >>> Now try to type some text, or change something. You will see the changes
752: affecting the text in the other window as well. That is because both
753: windows are displaying the same buffer, and therefor the same text. Changes
754: in the contents of the buffer have to affect both windows.
755:
756: >>> Let's now try to edit another file in this window. Give the command
757: C-X C-F and type the name of file as "/etc/motd". You now have two files
758: on your screen at the same time.
759:
760: >>> Type the command M- C-V (Meta followed by C-V) and watch the other window
761: page downward. This is very convenient when doing a variety of tasks, like
762: correcting errors in a file - edit the file, with the list of errors in
763: the other window!
764:
765: >>> Finally, let's get back to the main window (with this document) by typing
766: C-X p (or C-X n, since there are only two windows). Expand this window
767: to fill the entire screen by typing C-X 1.
768:
769: Enjoyable, wasn't it! There are other commands for shrinking and growing
770: windows, but one of the most useful when editing text like this is the command
771: which invokes JOVE's interactive spelling checker. It's called spell-buffer.
772: It runs the UNIX spell(1) command on the buffer, and puts the errors in
773: another buffer in another window, and allows you to edit the list to remove
774: the words you know are not errors. Then, type C-X C-C, which usually gets you
775: out of JOVE but in this case only gets you out of the spell-edit mode. You can
776: now go through the remaining spelling errors word-by-word, and you can correct
777: them. The commands for this are C-X C-N (for next error) and C-X C-P (for
778: previous error.)
779:
780: >>> Try the spell-buffer command now, by going M-X spel <space> and watch.
781: Delete a few errors, then type C-X C-C, and do a few C-X C-N's to find some
782: errors in this document. We've left a few ! (deliberately, of course!!!)
783:
784:
785: MACROS
786: ------
787: A "keyboard macro" is a command defined by the user to abbreviate a
788: sequence of other commands. If you discover that you are about to type
789: C-N C-D forty times, you can define a keyboard macro to do C-N C-D and
790: call it with a repeat count of forty. The commands which deal with
791: keyboard macros are:
792:
793: C-X ( Start defining a keyboard macro.
794: C-X ) End the definition of a keyboard macro.
795: C-X E Execute the most recent keyboard macro.
796:
797: You define a keyboard macro while executing the commands which are the
798: definition. Put differently, as you are defining a keyboard macro, the
799: definition is being executed for the first time. This way, you can see
800: what the effects of your commands are, so that you don't have to figure
801: them out in your head. When you are finished, the keyboard macro is
802: defined and also has been, in effect, executed once. You can then do the
803: whole thing over again by invoking the macro.
804:
805: To start defining a keyboard macro, type the C-X ( command. From then
806: on, your commands continue to be executed, but also become part of the
807: definition of the macro. "Def" appears in the mode line to remind you of
808: what is going on. When you are finished, the C-X ) command terminates
809: the definition (without becoming part of it!).
810:
811: The macro thus defined can be invoked again with the C-X E command
812: which may be given a repeat count as a numeric argument to execute the
813: macro many times. C-X ) can also be given a repeat count as an argument,
814: in which case it repeats the macro that many times right after defining
815: it, but defining the macro counts as the first repetition (since it is
816: executed as you define it). So, giving C-X ) an argument of 2 executes
817: the macro immediately one additional time. An argument of zero to C-X E
818: or C-X ) means repeat the macro indefinitely (until it gets an error).
819:
820: If you want to perform an operation on each line, then either you
821: should start by positioning point on the line above the first one to be
822: processed and then begin the macro definition with a C-N, or you should
823: start on the proper line and end with a C-N. Either way, repeating the
824: macro will operate on successive lines.
825:
826: >>> Place the cursor at the top of the screen and then enter the commands
827: below. Note that after the first command, "Def" appears in the mode
828: line.
829:
830: C-X (
831: C-A
832: *****
833: M-F
834: M-F
835: M-F
836: -----
837: C-N
838: C-X )
839:
840: >>> Notice that as you typed those commands in, they were executed. Now
841: move the cursor down a couple of lines, but keep it near the top of
842: the screen. Type the command C-U C-X E. This will execute your
843: macro 4 times.
844:
845: Although not described here, it is possible to both name your macros,
846: and to save and restore them from files. See the documentation for this.
847:
848: INITIALIZATION FILES
849: --------------------
850: You can initialize JOVE just the way you like it by putting a file
851: named ".joverc" in your home directory. To see what this file should
852: look like, look at the one in the directory /usr/src/local/jove/doc. The
853: file system.rc is one such file, the other example is example.rc. It
854: should be noted that the commands in this file contain control
855: characters, which may make it hard to read. Use the "cat -v" command
856: for this.
857:
858: To insert control characters into a file with JOVE, you should use
859: the C-Q command. Type C-Q <X> where <X> is the control character. Note that
860: C-Q will not work on some terminals, because it, like C-S, is used for
861: suspending and restoring the output to the terminal. In that case, use
862: the command M-X quo <space> <X>.
863:
864: INTERACTIVE SHELLS
865: ------------------
866:
867: One of JOVE's very powerful features is the ability to start up shells
868: within the editor, and then use shell commands within the screen editing
869: environment. To execute a command again, just cursor-up to it, change it if
870: you want with all the normal editing keys, and hit RETURN once to bring it
871: down to your present command line, and again to execute it. We'll bow out
872: here suggesting you consult the manual for hard details, or type M-X shell
873: <space> if you are the adventurous type!
874:
875: CONCLUSION
876: ----------
877:
878: Remember, to exit use C-X C-C.
879:
880: This tutorial is meant to be understandable to all new users, so if
881: you found something unclear, don't sit and blame yourself - complain!
882:
883: You'll probably find that if you use JOVE for a few days you won't
884: be able to give it up. Initially it may give you trouble. But remember
885: that this is the case with any editor, especially one that can do many,
886: many things. And JOVE can do practically everything.
887:
888: Hopefully you have enjoyed this tutorial, and, more importantly, I
889: hope you've learned something. If you use JOVE for about a week, and be
890: patient, you will find that it is more convenient and friendly to use
891: than any other editor you've used. I know. I did.
892:
893: ---------------------------------------------------------------------------
894: This tutorial was originally written by Richard Stallman for EMACS and
895: modified by Doug Kingston and Jonathan Payne for JOVE. The section on windows
896: was added at UofT by Mark Moraes. Comments on this document should be sent to
897: [email protected]. (12 February '86), or locally (at UofT), to
898: [email protected].
899:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.