XEmacs-Beta October 2001

xemacs-beta@xemacs.org

125 participants
182 discussions

Anand Narasimhan

This bug report will be sent to the XEmacs Development Team, not to your local site managers!! Please write in English, because the XEmacs maintainers do not have translators to read other languages for them. Please describe as succinctly as possible: - What happened. - What you thought should have happened. - Precisely what you were doing at the time. Please also include any C or lisp back-traces that you may have. ================================================================ Dear Bug Team! vc-cc does not seem to work. I loaded vc-cc by typing "M-x load-library: vc-cc. and I did find-file on a directory that is under clearcase. I get an error "Wrong number of arguments: vc-dired-mode, 1". ================================================================ System Info to help track down your bug: --------------------------------------- uname -a: SunOS anandn-ultra 5.6 Generic_105181-21 sun4u sparc ./configure '--with-gcc' '-cpp=/opt/sw/gnu/bin/cpp' '--x-includes=/usr/openwin/include' '--x-libraries=/usr/openwin/lib' '--site-prefixes=/opt/sw/gnu' '--site-includes=/opt/sw/gnu/include' '--site-libraries=/opt/sw/gnu/lib' '--prefix=/opt/sw/xemacs-21.4.4' '--with-prefix=no' '--with-cde' '--with-pop' '--with-workshop' '--with-site-lisp=yes' '--pdump' XEmacs 21.4.4 "Artificial Intelligence" configured for `sparc-sun-solaris2.6'. Compilation / Installation: Source code location: /auto/ntgqa/anandn/gnu/src/xemacs-21.4.4 Installation prefix: /opt/sw/xemacs-21.4.4 Additional header files: /opt/sw/gnu/include Additional libraries: /opt/sw/gnu/lib Additional prefixes: /opt/sw/gnu Runtime library search path: /opt/sw/gnu/lib:/usr/dt/lib:/usr/openwin/lib:/opt/sw/gnu/lib/gcc-lib/sparc-sun-solaris2.6/3.0.1/../../.. Operating system description file: `s/sol2.h' Machine description file: `m/sparc.h' Compiler: gcc -g -O3 -Wall -Wno-switch -Winline -Wmissing-prototypes -Wshadow -Wsign-compare -Wpointer-arith Relocating allocator for buffers: yes GNU version of malloc: yes Window System: Compiling in support for the X window system: - X Windows headers location: /usr/dt/include /usr/openwin/include - X Windows libraries location: /usr/dt/lib /usr/openwin/lib - Handling WM_COMMAND properly. Using Lucid menubars. Using Lucid scrollbars. Using Motif dialog boxes. Using Motif native widgets. TTY: Compiling in support for ncurses. Images: Compiling in support for GIF images (builtin). Compiling in support for XPM images. Compiling in support for PNG images. Compiling in support for JPEG images. Compiling in support for TIFF images. Sound: Compiling in support for sound (native). Databases: Compiling in support for DBM. Internationalization: Mail: Compiling in support for POP mail retrieval. Compiling in support for "dot-locking" mail spool file locking method. Other Features: Compiling in support for ToolTalk. Compiling in support for Sun WorkShop. Compiling in support for dynamic shared object modules. Using the new portable dumper. Load-Path Lisp Shadows: ---------------------- (/opt/sw/xemacs-21.4.4/lib/xemacs/xemacs-packages/lisp/edit-utils/setnu /opt/sw/xemacs-21.4.4/lib/xemacs/xemacs-packages/lisp/jde-2.2.8/setnu) Installed XEmacs Packages: ------------------------- ((xslt-process :version 1.05 :type regular) (xemacs-devel :version 1.37 :type single-file) (xemacs-base :version 1.55 :type regular) (w3 :version 1.2 :type regular) (vm :version 6.96 :type regular) (viper :version 1.26 :type regular) (view-process :version 1.11 :type regular) (vc-cc :version 1.16 :type regular) (vc :version 1.28 :type regular) (tooltalk :version 1.13 :type regular) (tm :version 1.29 :type regular) (time :version 1.11 :type regular) (textools :version 1.12 :type regular) (text-modes :version 1.32 :type single-file) (texinfo :version 1.2 :type regular) (supercite :version 1.18 :type regular) (strokes :version 1.08 :type regular) (speedbar :version 1.21 :type regular) (sounds-au :version 1.1 :type regular) (slider :version 1.13 :type regular) (sh-script :version 1.13 :type regular) (sgml :version 1.08 :type regular) (semantic :version 1.1 :type regular) (rmail :version 1.12 :type regular) (psgml :version 1.23 :type regular) (ps-print-nomule :version 1.05 :type regular) (prog-modes :version 1 .41 :type single-file) (pcomplete :version 1.01 :type regular) (pcl-cvs :version 1.55 :type regular) (pc :version 1.2 :type single-file) (os-utils :version 1.25 :type single-file) (net-utils :version 1.23 :type single-file) (mh-e :version 1.13 :type regular) (mew :version 1.14 :type regular) (mailcrypt :version 2.09 :type regular) (mail-lib :version 1.39 :type regular) (ispell :version 1.23 :type regular) (ilisp :version 1.19 :type regular) (igrep :version 1.08 :type regular) (hm--html-menus :version 1.16 :type regular) (gnus :version 1.57 :type regular) (gnats :version 1.12 :type regular) (fsf-compat :version 1.09 :type single-file) (frame-icon :version 1.09 :type regular) (forms :version 1.13 :type regular) (footnote :version 1.13 :type regular) (eterm :version 1.13 :type regular) (eshell :version 1.01 :type regular) (emerge :version 1.09 :type regular) (elib :version 1.08 :type single-file) (eieio :version 1.01 :type regular) (efs :version 1.26 :type regular) (edit-utils :version 1.69 :type single-file) (ediff :version 1.31 :type regular) (edebug :version 1.14 :type regular) (dired :version 1.11 :type regular) (dictionary :version 1.0 :type regular) (debug :version 1.14 :type regular) (cc-mode :version 1.26 :type regular) (calendar :version 1.16 :type regular) (calc :version 1.17 :type regular) (c-support :version 1.16 :type single-file) (build :version 1.02 :type regular) (auctex :version 1.25 :type regular) (apel :version 1.2 :type regular) (Sun :version 1.13 :type regular)) Features: -------- (mail-abbrevs xemacsbug shadow sendmail vc vc-hooks dired-faces dired-xemacs dired vc-cc tq comint ring vc-cc-hooks advice advice-preload pending-del fast-lock lazy-lock font-lock env time cus-face xslt-process-autoloads xemacs-devel-autoloads xemacs-base-autoloads w3-autoloads vm-autoloads viper-autoloads view-process-autoloads vc-cc-autoloads vc-autoloads tooltalk-autoloads tm-autoloads time-autoloads textools-autoloads text-modes-autoloads texinfo-autoloads supercite-autoloads strokes-autoloads speedbar-autoloads sounds-au-autoloads slider-autoloads sh-script-autoloads sgml-autoloads semantic-autoloads rmail-autoloads psgml-autoloads ps-print-nomule-autoloads prog-modes-autoloads pcomplete-autoloads pcl-cvs-autoloads pc-autoloads os-utils-autoloads net-utils-autoloads mh-e-autoloads mew-autoloads mailcrypt-autoloads mail-lib-autoloads ispell-autoloads ilisp-autoloads igrep-autoloads hm--html-menus-autoloads gnus-autoloads gnats-autoloads fsf-compat-autoloads frame-icon-autoloads forms-autoloads footnote-autoloads eterm-autoloads eshell-autoloads emerge-autoloads elib-autoloads eieio-autoloads efs-autoloads edit-utils-autoloads ediff-autoloads edebug-autoloads dired-autoloads dictionary-autoloads debug-autoloads cc-mode-autoloads calendar-autoloads calc-autoloads c-support-autoloads build-autoloads auctex-autoloads apel-autoloads Sun-autoloads lisp-autoloads loadhist auto-show fontl-hooks x-iso8859-1 gutter-items menubar-items x-menubar mode-motion mouse itimer auto-save lisp-mode easymenu iso8859-1 page buff-menu lib-complete help-nomule cus-file derived frame text-props obsolete cus-start custom widget cl-extra mini-cl cl cl-19 packages backquote very-early-lisp sparcworks tooltalk lucid-scrollbars cut-buffer lucid-menubars motif-dialogs x c-balloon-help tty-frames tty toolbar native-sound scrollbar unix-processes multicast network-streams subprocesses modules menu-accelerator-support menubar dbm md5 xemacs gutter tiff png gif jpeg xpm xbm lisp-float-type usg-unix-v dialog devices window-system base64) Recent keystrokes: ----------------- ESC x l o a d SPC l SPC RET v c - c c RET C-x C-f RET C-x C-f / v o b / n g / d BS BS BS t g / d e v / j TAB n TAB a d TAB m TAB s r TAB RET misc-user Recent messages (most recent first): ----------------------------------- Parsing /users/anandn/.mailrc... Loading mail-abbrevs...done Loading mail-abbrevs... Loading xemacsbug...done Wrong number of arguments: vc-dired-mode, 1 Loading xemacsbug... Reading directory /vob/ntg/dev/java/netsys/adminconsole/mpls/sreditor/...done Reading directory /vob/ntg/dev/java/netsys/adminconsole/mpls/sreditor/... Reading directory /users/anandn/...done Reading directory /users/anandn/... Loading dired...done Loading dired... Loading vc-cc...done Loading vc-cc... Loading usg-unix-v-emacs.el...done Loading pending-del...done Loading pending-del... Loading fast-lock...done Loading fast-lock... Loading lazy-lock...done

2 participants
2 comments

mail-lib sync and Gnus package 23 years, 1 month

Simon Josefsson

I'm trying to sync Emacs sendmail.el with mail-lib, and it seems that the Emacs version RFC 2047 encodes non-ASCII user names. So unless mail-lib require the gnus package (which is bad), some files would need to be moved from the gnus package into the mail-lib package, namely at least the following (determined by looking at `require' lines, but there may be hidden dependencies): rfc2047.el qp.el mm-util.el ietf-drums.el time-date.el parse-time.el mail-prsvr.el The rfc2047.el file would probably need modifications to work without the following files as well: gnus-util.el nnheader.el What do you think, especially the gnus package maintainer? MIME is probably a Pandora's box that will drag in lots of files into mail-lib, but it is probably inevitable unless we want `M-x mail' to be a ASCII-only thing, which I think is wrong. What could be a problem though, is if some MIME related package requires Mule, but I don't think this is the case.

2 participants
1 comments

new TUTORIAL; need translation help! 23 years, 1 month

Ben Wing

I've made extensive updates to the tutorial. The tutorial was ancient, full of GNU-Emacs-specific things that were done differently on XEmacs, and very much focused on TTY's. I redid all of this, so that it now reflects standard XEmacs ways of doing things and focuses primarily on window systems (e.g. window-system bindings are used in the examples and are considered the "standard" way of doing things; TTY bindings are mentioned parenthetically). There are a very small number of things in the tutorial that don't quite currently make sense for 21.5; that's because I wrote it with my new Mule workspace in mind, where I've changed a few key bindings [mostly, I made ESC ESC the standard "all-purpose exit" on window systems, and left the triple ESC ESC ESC for TTY's, since ESC ESC is a lot more convenient and TTY users have to deal with lots of different bindings anyway]. I'm looking for people to update the various foreign-language versions of the tutorial. We also have versions of tutorials in five new languages, from GNU Emacs. [Spanish, Dutch, Czech, Slovak, Slovenian] However, these will need extensive updating for the new tutorial, as will the others. Please help! I'm attaching my new tutorial, plus the versions in the five new languages. ben You are looking at the XEmacs tutorial. See end for copyrights and conditions. XEmacs commands generally involve the CONTROL key (sometimes labeled CTRL or CTL) or the META key. "META" is a traditional Emacs term; on most keyboards, the key is labelled "Alt". (On Sun keyboards, the META key is labelled with a diamond, and is *NOT* the Alt key, which also exists.) On some TTY's, there is no META key; in this case, use ESC. Rather than write out META or CONTROL each time we want you to prefix a character, we'll use the following abbreviations: C-<chr> means hold the CONTROL key while typing the character <chr> Thus, C-f would be: hold the CONTROL key and type f. M-<chr> means hold the META (i.e. Alt) key down while typing <chr>. (See above for Sun keyboards and TTY's.) Important note: to end the XEmacs session, type C-x C-c. (Two characters.) To move to the next screen, type <Next> (often labeled PgDn). On TTY's, you may not have such a key; use C-v instead. (Hold down the CONTROL key while typing v.) To move to the previous screen, type <Prior> (often labeled PgUp). On TTY's, use M-v. (Remember, this means META + v; if you have no META or Alt key that works, press and release ESC, then type v.) The characters ">>" at the left margin indicate directions for you to try using a command. For instance: >> Try typing <Next> and then <Prior>, a few times. (Or C-v and M-v, on TTY's.) Note that there is an overlap of two lines when you move from screen to screen; this provides some continuity so you can continue reading the text. In general, every "cursor key" (the arrows and similar keys set off to the right side of the keyboard) has an equivalent binding that uses only the alphanumeric keys in combination with CONTROL and/or META, so that TTY users can use XEmacs. (In fact, in olden days, this "older way" was the only way to do things, and you will still often see references to these keys as the "recommended" way of doing things. We don't actually recommend that you use these older bindings in preference to the more obvious cursor keys, since the cursor keys are easier to remember and usually more convenient to use. However, it's useful to know the older bindings, either in case you ever use a TTY or so that you can make sense of references to them. From now on, we will mention the TTY bindings in parentheses, and expect that TTY users will subsitute them whenever we mention a cursor key.) Now you may ask, what is a TTY? A TTY (or "TeleTYpe")is a text-only connection, the kind you get when you use the "telnet" program to log into a remote site. Up till 20 years ago or so, such text-only connections were all that existed to communicate with a computer, usually via a "terminal" (a combination keyboard and monochrome screen) connected directly to a computer. Nowadays, such dedicated TTY's are increasingly rare, and most people only run into them when using telnet. Emacs began in those olden days, and it still carries some baggage from that time, but things have greatly improved since then. Now, you are probably using XEmacs under MS Windows or X Windows, collectively termed a "window system". * SUMMARY --------- The following commands are useful for viewing screenfuls: <Next> Move forward one screenful (C-v on TTY's) <Prior> Move backward one screenful (M-v on TTY's) C-l Clear screen and redisplay all the text, moving the text around the cursor to the center of the window. (That's CONTROL-L, not CONTROL-1.) >> Find the cursor, and note what text is near it. Then type C-l. Find the cursor again and notice that the same text is near the cursor now. * BASIC CURSOR CONTROL ---------------------- The first thing that you need to know is how to move around from place to place in the text. You already know how to move forward and backward one screen, but how do you move to a specific place within the text on the screen? There are several ways you can do this. The most basic way is to use the arrow keys, which we refer to as <Left>, <Right>, <Up>, and <Down>. Each of these commands moves the cursor one row or column in a particular direction on the screen. On a TTY, the arrow keys should, hopefully, work the same, but they might not, since TTY's are easy to misconfigure. As mentioned above, for all cursor-key bindings, there are equivalent alphanumeric ones. In this case, the bindings are unfortunately not at all obvious, since they were chosen mnemonically and not visually. Here is a table showing the TTY bindings: Previous line, C-p : : Backward, C-b .... Current cursor position .... Forward, C-f : : Next line, C-n >> Move the cursor to the line in the middle of that diagram using <Down> or <Up>. Then type C-l to see the whole diagram centered in the window. (Remember, TTY users should substitute the appropriate bindings whenever necessary. In this case, use C-n and C-p.) Note the mnemonic significance of the TTY bindings: P for previous, N for next, B for backward and F for forward. If you're on a TTY, you really should spend some time now etching these cursor bindings into your brain. These cursor positioning commands are the most fundamental way to move around and you'll be using them ALL the time, so you will be completely lost without them. Even if you are on a window system and are not forced to learn these bindings, you should try to memorize at least these four commands and in particular their associated words, since variations on them show up in many different keyboard commands, and knowing what they stand for can be of tremendous help. >> Do a few <Down>'s to bring the cursor down to this line. >> Move into the line with <Right>'s and then up with <Up>'s. See what <Up> does when the cursor is in the middle of the line. The location of the cursor in the text is also called "point". You will often see such references to "point" in the documentation, so remember this term. Each line of text ends with a Newline character, which serves to separate it from the following line. The last line in your file ought to have a Newline at the end. XEmacs does not normally require it to have one, but you can change this -- see the menu entry "Options/Editing/Newline at End of File...". (More on menu entries later.) >> Try to <Left> at the beginning of a line. It should move to the end of the previous line. This is because it moves back across the Newline character. <Right> can move across a Newline just like <Left>. >> Do a few more <Left>'s, so you get a feel for where the cursor is. Then do <Right>'s to return to the end of the line. Then do one more <Right> to move to the following line. When you move past the top or bottom of the window, the text beyond the edge shifts onto the screen. This is called "scrolling". It enables XEmacs to move the cursor to the specified place in the text without moving it off the screen. >> Try to move the cursor off the bottom of the window with <Down>, and see what happens. If moving by characters is too slow, you can move by words. C-<Right> (CONTROL + right-arrow key) moves forward a word and C-<Left> moves back a word. On TTY's, use M-f instead of C-<Right> and M-p instead of C-<Left>. >> Type a few C-<Right>'s and C-<Left>'s. When you are in the middle of a word, C-<Right> moves to the end of the word. When you are in whitespace between words, C-<Right> moves to the end of the following word. C-<Left> works likewise in the opposite direction. >> Type C-<Right> and C-<Left> a few times, interspersed with <Right>'s and <Left>'s so that you can observe the action of C-<Right> and C-<Left> from various places inside and between words. Notice the parallel between <Right> and <Left> on the one hand, and C-<Right> and C-<Left> on the other hand. Also notice the parallel between C-f and C-p on the one hand, and M-f and M-p on the other hand. XEmacs tries fairly hard to maintain parallelism in keyboard commands to make them easier to remember, and generally adding CONTROL or META to an operation makes it "more so". META goes beyond CONTROL, often making the units of movement less basic in the process -- words vs. characters, balanced parenthetical expressions vs. words, or sentences vs. lines. Other important cursor motion commands are <Home> and <End> (beginning and end of the line), and C-<Home> and C-<End> (beginning and end of the whole text). Note again the parallelism just mentioned. On TTY's, use C-a and C-e for beginning and end of line, and M-< and M-> for beginning and end of text. (If it helps, think of A as the first letter of the alphabet, and E as standing for "end".) Note that the < and > chars (Less-than and Greater-than) are above the comma and period on most keyboards, so you'll have to use the SHIFT key in conjunction with META. If you have no META, the order is very important: Type ESC first, then type < or >. >> Move the cursor to this line, then try <Home> and <End> a few times. >> (Read this entire entry before doing anything!) Try C-<Home> now, to move to the beginning of the tutorial. Then use <Next> repeatedly to move back here. >> Try all of these commands now a few times for practice. These are the most often used commands. Here is a summary of simple cursor-moving operations. Don't worry if you can't remember everything; you can always move back to this table for reference. KEYSTROKE: SEQUENCE TTY: <Prior> (PgUp) Move backward a screen M-v <Next> (PgDn) Move forward a screen C-v <Left> Move backward a character C-b <Right> Move forward a character C-f C-<Left> Move backward a word M-b C-<Right> Move forward a word M-f <Up> Move to previous line C-p <Down> Move to next line C-n C-<Up> Move 6 lines up C-<Down> Move 6 lines down <Home> Move to beginning of line C-a <End> Move to end of line C-e C-<Home> Move to beginning of text M-< C-<End> Move to end of text M-> * PREFIX ARGUMENTS ------------------ Most XEmacs commands accept a numeric argument; for most commands, this serves as a repeat-count. The way you give a command a repeat count is by holding down the META key while typing the digits. You really only need to hold down META for the first digit; for this reason, an alternative method is to simply hit the ESC key once, then type the digits. (This latter method works on TTY's as well.) The numeric argument is also called a "prefix argument", because you type the argument before the command it applies to. For instance, M-8 <Right> moves forward eight characters. >> Try using <Down> or <Up> with a numeric argument, to move the cursor to a line near this one with just one command. Sometimes, commands use the term "prefix argument" to refer not to a numeric argument, but to just a flag that makes the command do something different if given. (We haven't encountered any such commands so far.) For such commands, the flag is normally given by typing C-u before the command, but generally you can also specify any numeric argument -- the actual number makes no difference. * SCROLLBARS ------------ Unless you are on a TTY, there is probably a rectangular area called a scroll bar at the right hand side of the XEmacs window. You can scroll the text by manipulating the scrollbar with the mouse. The scrollbar has a button in the middle of it, called a thumb. The relative position of this thumb within the rectangle indicates where you are within the file. As you scroll up or down with the cursor keys, the thumb will follow. >> Try holding down the left button on the thumb and moving the mouse up and down. You'll see that the text scrolls up and down as you move the mouse. (NOTE: Some scrollbars, such as the Athena scrollbars under X Windows, work differently. On these, you will have to use the middle button, not the left one.) >> Try clicking the left button in the area above the thumb. This should scroll the text up by a screenful. Similarly, clicking the button below the thumb will scroll down by a screenful. (NOTE: Under Athena, things work differently.) Holding the button down will cause the text to repeatedly scroll by a screenful. >> Most scrollbars have arrows at the top and bottom of the rectangle. Clicking on these will scroll the text up or down by a line, and holding the button down will cause the text to repeatedly scroll by a line. * USING THE MENU ---------------- Unless you are on a TTY, you will notice a menubar at the top of the XEmacs frame. You can use this menubar to access all the most common XEmacs commands, such as "open a file". You will find this easier at first, because you don't need to remember the keystrokes necessary to access any particular command. Once you are comfortable with XEmacs, it will be easy to begin using the keyboard commands because each menu item with a corresponding keyboard command has the command listed next to it. Note that there are many items in the menubar that have no exact keyboard equivalents. For example, the Buffers menu lists all of the available buffers in most-recently used order. You can switch to any buffer by simply findings its name in the Buffers menu and selecting it. You can also configure XEmacs so that you can use the META key to access menu items -- the "accelerator" functionality that is standard under MS Windows. One easy way to do this in XEmacs is using the menu item "Options/Menubars/Alt/Meta Selects Menu Items". (The final slash between "Alt" and "Meta" is part of the item name.) When this feature is on, you can select a menu or menu item using the combination of META (i.e. Alt) plus the underlined letter of the menu item. For example, to exit XEmacs, use M-f M-x. We currently don't turn this on by default because it interferes with the traditional usage of META in XEmacs. However, we may do this in the future: Only commands for which there are top-level menus are shadowed by accelerator bindings, and for all those commands, there are equivalents either using cursor keys or on the menus. When we mention a menu selection, it will be specified as just shown -- i.e. a string, with slashes separating different submenus or items. In this case, the menu entry just mentioned means "Click the Options menu on the menubar, then the Menubars submenu, the the entry off of that labeled "Alt/Meta Selects Menu Items". In general, XEmacs is highly customizable, and one of these easiest ways to make such customizations is through the Options menu. IMPORTANT: If you want a change on the Options menu to last beyond the current XEmacs session, use "Options/Save Options to Init File". This way, it will be permanent. Otherwise, all Options changes made in the current session will be lost. * WHEN XEMACS IS HUNG OR IN SOME STRANGE MODE --------------------------------------------- If XEmacs stops responding to your commands, you can stop it safely by typing C-g. You can use C-g to stop a command which is taking too long to execute. You can also use C-g to discard a numeric argument or the beginning of a command that you do not want to finish. >> Type M-100 to make a numeric arg of 100 (remember, this means hold down META and type 100, or type ESC 1 0 0), then type C-g. Now type <Right>. It should move just one character, because you canceled the argument with C-g. If XEmacs is in some strange mode and C-g isn't getting out of it, you can use the all-purpose escape mechanism: ESC ESC. (On TTY's, you have to use ESC ESC ESC. The reasons for this are a bit complicated.) Hitting ESC ESC will get you out of almost any weird mode, including selected text, split windows, the minibuffer, recursive edits, "stranded minibuffer requests", and the like. If you have many problems at once, each invokation of ESC ESC will get rid of one, so keep repeating until everything's fixed. REMEMBER: ESC ESC does not work if XEmacs is hung doing some time-consuming operation or running broken code. Use C-g for that. * DISABLED COMMANDS ------------------- Some XEmacs commands are "disabled" so that beginning users cannot use them by accident. If you type one of the disabled commands, XEmacs displays a message saying what the command was, and asking you whether you want to go ahead and execute the command. If you really want to try the command, type Space in answer to the question. Normally, if you do not want to execute the disabled command, answer the question with "n". >> Type `C-x n p' (which is a disabled command), then type n to answer the question. * "WINDOWS", I.E. PANES ----------------------- XEmacs can have several panes (i.e. non-overlapping divisions of a window or a TTY screen), each displaying its own text. For historical reasons, these panes are called "windows", and what we normally think of as a window is called a "frame". XEmacs can also have multiple "frames"; this is described later. From now on, we omit the quotes around the XEmacs terms, and if we need to use "window" in the standard sense, we will say "window-system window". At this stage it is better not to go too deeply into the techniques of using multiple windows. But you do need to know how to get rid of extra windows that may appear to display help or output from certain commands. Most of the time, your cursor will be in the new window; if this is the case, simply type q. Alternatively, you can type C-x 0 Delete window. That is, CONTROL-x followed by the digit 0. This command is unlike the other commands you have learned in that it consists of two characters. It starts with the character CONTROL-x. There is a whole series of commands that start with CONTROL-x; many of them have to do with windows, files, buffers, and related things. These commands are two, three or four characters long. >> Move the cursor to this line and type M-0 C-l. (That's a zero, not an Oh.) >> Type CONTROL-h k CONTROL-f. See how this window shrinks, while a new one appears to display documentation on the CONTROL-f command. >> Type q and see the documentation listing window disappear. (Remember that C-l redraws the screen. If you give a numeric argument to this command, it means "redraw the screen and put the current line that many lines from the top of the window." So M-0 C-l means "redraw the screen, putting the current line at the top.") * INSERTING AND DELETING ------------------------ If you want to insert text, just type the text. Characters which you can see, such as A, 7, *, etc. are taken by XEmacs as text and inserted immediately. Type <Return> (the carriage-return key) to insert a Newline character. You can delete the last character you typed by typing <Backspace>. <Backspace> is a key on the keyboard, which may be labeled simply with a left arrow sign. (NOTE: On a few misconfigured TTY's, typing <Backspace> may try to invoke the help system; the symptom of this is a line like "C-h (Type ? for further options)" at the bottom of the screen. If this is the case, type C-g to get out of this, and try using <Delete> from now on in place of <Backspace>.) More generally, <Backspace> deletes the character immediately before the current cursor position. >> Do this now--type a few characters, then delete them by typing <Backspace> a few times. Don't worry about this file being changed; you will not alter the master tutorial. This is your personal copy of it. When a line of text gets too big for one line on the frame, the line of text is "continued" onto a second frame line. An arrow at the right margin that hooks down and to the left (or a backslash ("\") on TTY's) indicates a line which has been continued. >> Insert text until you reach the right margin, and keep on inserting. You'll see a continuation line appear. >> Use <Backspace>s to delete the text until the line fits on one frame line again. The continuation line goes away. You can delete a Newline character just like any other character. Deleting the Newline character between two lines merges them into one line. If the resulting combined line is too long to fit in the frame width, it will be displayed with a continuation line. >> Move the cursor to the beginning of a line and type <Backspace>. This merges that line with the previous line. >> Type <Return> to reinsert the Newline you deleted. Remember that most XEmacs commands can be given a repeat count; this includes text characters. Repeating a text character inserts it several times. >> Try that now -- type M-8 * to insert ********. You've now learned the most basic way of typing something in XEmacs and correcting errors. You can delete by words or lines as well. Here is a summary of the delete operations: <Backspace> delete the character just before the cursor <Delete> delete the next character after the cursor C-d same as <Delete> but works on TTY's M-<Backspace> cut ("kill") the word immediately before the cursor M-<Delete> cut ("kill") the next word after the cursor M-d same as M-<Delete> but works on TTY's C-k cut ("kill") from the cursor position to end of line M-k cut ("kill") to the end of the current sentence Notice again the parallelism with no modifier vs. CONTROL vs. META that was mentioned earlier -- although the parallels are not perfect. (In the violent old days when Emacs first began, removing text that could later be re-inserted was called "killing", and re-inserting was called "yanking" -- evidently the designers of Emacs must have been thinking of role-playing games, where killed characters could be easily resurrected with the wave [yank?] of a magic wand. In the more genteel [and realistic] times we live in, the preferred terms are "cut" and "paste".) You can also kill any part of the buffer with one uniform method. Under window systems, the preferred method is to move to one end of that part, hold the SHIFT key down, and use the cursor keys to move to the other end. Then release the SHIFT key and type C-w. That kills all the text between the two positions. An alternative method, which also works on TTY's, is to move to one end of the text, and type C-＠ or C-SPC (either one). (SPC is the Space bar.) Move to the other end and type C-w. >> Move the cursor to the A at the start of the previous paragraph. >> Hold the SHIFT key down. >> Move the cursor to the n in "end", on the third line of the paragraph. >> Release the SHIFT key and type C-w. This will kill the text starting from the A, and ending just before the n. Now try it the other way. >> Type C-/ to undo the killing, or C-_ or C-x u on TTY's. >> Move the cursor to the same A again. >> Type C-SPC. XEmacs should display a message "Mark set" at the bottom of the frame. >> Move the cursor to the n in "end", on the third line of the paragraph. >> Type C-w. You will get the same result as previously. The difference between "killing" and "deleting" is that "killed" text can be reinserted, whereas "deleted" things cannot be reinserted. Reinsertion of killed text is called "yanking". Generally, the commands that can remove a lot of text kill the text (they set up so that you can yank the text), while the commands that remove just one character, or just blank lines and spaces, do deletion (so you cannot yank that text). Normally, on a window system "killing" text stores it internally but also puts it on the clipboard, just like Cut in a word processor, and "yanking" takes text from the clipboard if available, just like Paste. (This connection to the clipboard can be turned off from the Options menu.) There are also menu items, "Edit/Cut" and "Edit/Paste", that always connect with the clipboard, and equivalent Cut and Paste keys on Sun keyboards. >> Move the cursor to the beginning of a line which is not empty. Then type C-k to kill the text on that line. >> Type C-k a second time. You'll see that it kills the Newline which follows that line. Note that a single C-k kills the contents of the line, and a second C-k kills the line itself, and makes all the other lines move up. C-k treats a numeric argument specially: it kills that many lines AND their contents. This is not mere repetition. M-2 C-k kills two lines and their newlines; typing C-k twice would not do that. Bringing back killed text is called "yanking". (Think of it as yanking back, or pulling back, some text that was taken away.) You can yank the killed text either at the same place where it was killed, or at some other place in the buffer, or even in a different file. You can yank the text several times, which makes multiple copies of it. The command for yanking is C-y. It reinserts the last killed text, at the current cursor position. >> Try it; type C-y to yank the text back. If you do several C-k's in a row, all of the killed text is saved together, so that one C-y will yank all of the lines at once. >> Do this now, type C-k several times. Now to retrieve that killed text: >> Type C-y. Then move the cursor down a few lines and type C-y again. You now see how to copy some text. What do you do if you have some text you want to yank back, and then you kill something else? C-y would yank the more recent kill. But the previous text is not lost. You can get back to it using the M-y command. After you have done C-y to get the most recent kill, typing M-y replaces that yanked text with the previous kill. Typing M-y again and again brings in earlier and earlier kills. When you have reached the text you are looking for, you do not have to do anything to keep it. Just go on with your editing, leaving the yanked text where it is. If you M-y enough times, you come back to the starting point (the most recent kill). >> Kill a line, move around, kill another line. Then do C-y to get back the second killed line. Then do M-y and it will be replaced by the first killed line. Do more M-y's and see what you get. Keep doing them until the second kill line comes back, and then a few more. If you like, you can try giving M-y positive and negative arguments. * UNDO ------ If you make a change to the text, and then decide that it was a mistake, you can undo the change with the undo command, C-/. (On TTY's, use C-_, i.e. CONTROL + underscore, which is normally above the minus sign; i.e. you will have to hold the SHIFT key down, as in CONTROL + SHIFT + minus. If that doesn't work, you can fall back to C-x u; but that has the unfortunate property that it's difficult to execute several times in a row.) Normally, C-/ undoes the changes made by one command; if you repeat the C-/ several times in a row, each repetition undoes one additional command. But there are two exceptions: commands that do not change the text do not count (this includes cursor motion commands and scrolling command), and self-inserting characters are usually handled in groups of up to 20. (This is to reduce the number of C-/'s you have to type to undo insertion of text.) >> Kill this line with C-k, then type C-/ and it should reappear. A numeric argument to C-/ acts as a repeat count. If you change your mind and want to redo changes that you've undone, issue any command other than Undo (usually people move the cursor), and then start undoing again. This will undo your Undo changes; keep hitting Undo, and you will eventually undo all the Undo's, and start undoing your original changes. Essentially, XEmacs treats each Undo as a further change, and records them for undoing just like regular commands; but as long as you keeping issuing Undo commands directly after previous ones, XEmacs remembers where you are in the Undo history so it can keep undoing. Once you issue another command, XEmacs "forgets" and resets its internal pointer to the end of the Undo history. This may seem confusing, so try it out: >> Type a line of text above this one. >> Move to the end of the line you just typed, and hit <Backspace> until you've deleted all characters. >> Type C-/ a number of times to undo some of your deletions. >> Move the cursor left. >> Start typing C-/ again, and it will redo your deletions until there's no text left, then it will start undoing the original deletions. When all the text appears again, further C-/'s will undo the text you originally typed, in groups of up to 20 (see above). As you just saw, you can undo deletion of text just as you can undo killing of text. The distinction between killing something and deleting it affects whether you can yank it with C-y; it makes no difference for undo. * USING THE MOUSE ----------------- On window systems, XEmacs is fully integrated with the mouse. You can position the text cursor by clicking the left button at the desired location, and you can select text by dragging the left mouse button across the text you want to select. (Or alternatively, click the left mouse button at one end of the text, then move to the other end and use Shift-click to select the text.) The middle mouse button is commonly used to choose items that are visible on the screen. For example, if you enter Info (the on-line XEmacs documentation) using C-h i or the Help menu, you can follow a highlighted link by clicking the middle mouse button on it. Similarly, if you are typing a file name in (e.g. when prompted by "Find File") and you hit <Tab> to show the possible completions, you can click the middle mouse button on one of the completions to select it. If you have a two-button mouse, such as some MS Windows systems, you can click both buttons simultaneously to simulate the middle button. The right mouse button brings up a popup menu, called a "context menu" because the contents vary depending on what context you're in, such as the mode of the window you click in or the text under the mouse. The menu usually contains the commands most relevant to where you clicked, so they're easier to access. >> Press the right mouse button now. Under X Windows, you may have to hold the button down in order to keep the menu up. * FILES ------- In order to make the text you edit permanent, you must put it in a file. Otherwise, it will go away when your invocation of XEmacs goes away. In order to put your text in a file, you must "find" the file before you enter the text. (This is also called "visiting" the file.) Finding a file means that you see the contents of the file within XEmacs. In many ways, it is as if you were editing the file itself. However, the changes you make using XEmacs do not become permanent until you "save" the file. This is so you can avoid leaving a half-changed file on the system when you do not want to. Even when you save, XEmacs leaves the original file under a changed name in case you later decide that your changes were a mistake. If you look near the bottom of the frame you will see a line that begins and ends with dashes, and contains the string "XEmacs: TUTORIAL" or something like that. This part of the frame normally shows the name of the file that you are visiting. Right now, you are visiting a file called "TUTORIAL" which is your personal scratch copy of the XEmacs tutorial. When you find a file with XEmacs, that file's name will appear in that precise spot. One special thing about the command for finding a file is that you have to say what file name you want. We say the command "reads an argument from the terminal" (in this case, the argument is the name of the file). After you type the command C-x C-f Find a file XEmacs asks you to type the file name. The file name you type appears on the bottom line of the frame. The bottom line is called the minibuffer when it is used for this sort of input. You can use ordinary XEmacs editing commands to edit the file name. While you are entering the file name (or any minibuffer input), you can cancel the command with C-g. >> Type C-x C-f, then type C-g. This cancels the minibuffer, and also cancels the C-x C-f command that was using the minibuffer. So you do not find any file. When you have finished entering the file name, type <Return> to terminate it. Then C-x C-f command goes to work, and finds the file you chose. The minibuffer disappears when the C-x C-f command is finished. In a little while the file contents appear on the screen, and you can edit the contents. When you wish to make your changes permanent, type the command C-x C-s Save the file This copies the text within XEmacs into the file. The first time you do this, XEmacs renames the original file to a new name so that it is not lost. The new name is made by adding "~" to the end of the original file's name. When saving is finished, XEmacs displays the name of the file written. You should save fairly often, so that you will not lose very much work if the system should crash. >> Type C-x C-s, saving your copy of the tutorial. This should show "Wrote ...TUTORIAL" at the bottom of the frame. NOTE: On some older TTY connections, typing C-s will freeze the screen and you will see no further output from XEmacs. This indicates that an operating system "feature" called "flow control" is intercepting the C-s and not letting it get through to XEmacs. To unfreeze the screen, type C-q. Then see the section "Spontaneous Entry to Incremental Search" in the XEmacs manual for advice on dealing with this "feature". You can find an existing file, to view it or edit it. You can also find a file which does not already exist. This is the way to create a file with XEmacs: find the file, which will start out empty, and then begin inserting the text for the file. When you ask to "save" the file, XEmacs will really create the file with the text that you have inserted. From then on, you can consider yourself to be editing an already existing file. * BUFFERS --------- If you find a second file with C-x C-f, the first file remains inside XEmacs. You can switch back to it by finding it again with C-x C-f. This way you can get quite a number of files inside XEmacs. >> Create a file named "foo" by typing C-x C-f foo <Return>. Then insert some text, edit it, and save "foo" by typing C-x C-s. Finally, type C-x C-f TUTORIAL <Return> to come back to the tutorial. XEmacs stores each file's text inside an object called a "buffer". Finding a file makes a new buffer inside XEmacs. To see a list of the buffers that currently exist in your XEmacs job, type C-x C-b List buffers >> Try C-x C-b now. See how each buffer has a name, and it may also have a file name for the file whose contents it holds. Some buffers do not correspond to files. For example, the buffer named "*Buffer List*" does not have any file. It is the buffer which contains the buffer list that was made by C-x C-b. ANY text you see in an XEmacs window is always part of some buffer. >> Type ESC ESC to get rid of the buffer list. (Remember, three ESC's under TTY's.) If you make changes to the text of one file, then find another file, this does not save the first file. Its changes remain inside XEmacs, in that file's buffer. The creation or editing of the second file's buffer has no effect on the first file's buffer. This is very useful, but it also means that you need a convenient way to save the first file's buffer. It would be a nuisance to have to switch back to it with C-x C-f in order to save it with C-x C-s. So we have C-x s Save some buffers C-x s asks you about each buffer which contains changes that you have not saved. It asks you, for each such buffer, whether to save the buffer. >> Insert a line of text, then type C-x s. It should ask you whether to save the buffer named TUTORIAL. Answer yes to the question by typing "y". * EXTENDING THE COMMAND SET --------------------------- There are many, many more XEmacs commands than could possibly be put on all the control and meta characters. XEmacs gets around this with the X (eXtend) command. This comes in two flavors: C-x Character eXtend. Followed by one character. M-x Named command eXtend. Followed by a long name. These are commands that are generally useful but used less than the commands you have already learned about. You have already seen two of them: the file commands C-x C-f to Find and C-x C-s to Save. Another example is the command to end the XEmacs session--this is the command C-x C-c. (Do not worry about losing changes you have made; C-x C-c offers to save each changed file before it kills the XEmacs.) If you have installed the sample init.el file, you will find that C-x C-c does not exit XEmacs, but instead outputs a message. This is intentional, since C-x C-c is easy to hit accidentally. Instead, use the "File/Exit XEmacs" menu item to exit. If you are on a TTY, and you want to exit temporarily to execute a shell command, you should use C-z instead of C-x C-c. Under TTY's, C-z "suspends" XEmacs; that is, it returns to the shell but does not destroy the XEmacs. In the most common shells, you can resume XEmacs with the `fg' command or with `%xemacs'. (On systems which do not implement suspending, C-z creates a subshell running under XEmacs to give you the chance to run other programs and return to XEmacs afterward; it does not truly "exit" from XEmacs. In this case, the shell command `exit' is the usual way to get back to XEmacs from the subshell.) There are many C-x commands. Here is a list of the ones you have learned: C-x C-f Find file. C-x C-s Save file. C-x C-b List buffers. C-x C-c Quit XEmacs. C-x 0 Delete the current window. C-x u Undo (TTY version). Named eXtended commands are commands which are used even less frequently, or commands which are used only in certain modes. An example is the command replace-string, which globally replaces one string with another. When you type M-x, XEmacs prompts you at the bottom of the frame with M-x and you should type the name of the command; in this case, "replace-string". Just type "repl s<Tab>" and XEmacs will complete the name. (<Tab> is the Tab key, usually found above the CapsLock or Shift key near the left edge of the keyboard.) End the command name with <Return>. The replace-string command requires two arguments--the string to be replaced, and the string to replace it with. You must end each argument with <Return>. >> Move the cursor to the blank line two lines below this one. Then type M-x repl s<Return>changed<Return>altered<Return>. Notice how this line has changed: you've replaced the word c-h-a-n-g-e-d with "altered" wherever it occurred, after the initial position of the cursor. * AUTO SAVE ----------- When you have made changes in a file, but you have not saved them yet, they could be lost if your computer crashes. To protect you from this, XEmacs periodically writes an "auto save" file for each file that you are editing. The auto save file name has a # at the beginning and the end; for example, if your file is named "hello.c", its auto save file's name is usually "#hello.c#". When you save the file in the normal way, XEmacs deletes its auto save file. If the computer crashes, you can recover your auto-saved editing by finding the file normally (the file you were editing, not the auto save file) and then typing M-x recover file<Return>. When it asks for confirmation, type yes<Return> to go ahead and recover the auto-save data. * ECHO AREA ----------- If XEmacs sees that you are typing multicharacter commands slowly, it shows them to you at the bottom of the frame in an area called the "echo area". The echo area contains the bottom line of the frame. * MODELINE ---------- The line immediately above the echo area it is called the "modeline". The mode line says something like this: --**-XEmacs: TUTORIAL (Fundamental)--L670--58%---------------- This line gives useful information about the status of XEmacs and the text you are editing. You already know what the filename means--it is the file you have found. -NN%-- indicates your current position in the text; it means that NN percent of the text is above the top of the window. If the top of the file is on the screen, it will say --Top-- instead of --00%--. If the bottom of the text is on the screen, it will say --Bot--. If you are looking at text so small that all of it fits on the screen, the mode line says --All--. The L and digits indicate position in another way: they give the current line number of point. The stars near the front mean that you have made changes to the text. Right after you visit or save a file, that part of the mode line shows no stars, just dashes. The part of the mode line inside the parentheses is to tell you what editing modes you are in. The default mode is Fundamental which is what you are using now. It is an example of a "major mode". XEmacs has many different major modes. Some of them are meant for editing different languages and/or kinds of text, such as Lisp mode, Text mode, etc. At any time one and only one major mode is active, and its name can always be found in the mode line just where "Fundamental" is now. Each major mode makes a few commands behave differently. For example, there are commands for creating comments in a program, and since each programming language has a different idea of what a comment should look like, each major mode has to insert comments differently. Each major mode is the name of an extended command, which is how you can switch to that mode. For example, M-x fundamental-mode is a command to switch to Fundamental mode. If you are going to be editing English text, such as this file, you should probably use Text Mode. >> Type M-x text-mode<Return>. Don't worry, none of the XEmacs commands you have learned changes in any great way. But you can observe that C-<Right> and C-<Left> now treat apostrophes as part of words. Previously, in Fundamental mode, C-<Right> and C-<Left> treated apostrophes as word-separators. Major modes usually make subtle changes like that one: most commands do "the same job" in each major mode, but they work a little bit differently. To view documentation on your current major mode, type C-h m. >> Use M-4 C-l to bring this line near the top of the window. >> Type C-h m, to see how Text mode differs from Fundamental mode. >> Type q to remove the documentation from the screen. Major modes are called major because there are also minor modes. Minor modes are not alternatives to the major modes, just minor modifications of them. Each minor mode can be turned on or off by itself, independent of all other minor modes, and independent of your major mode. So you can use no minor modes, or one minor mode, or any combination of several minor modes. One minor mode which is very useful, especially for editing English text, is Auto Fill mode. When this mode is on, XEmacs breaks the line in between words automatically whenever you insert text and make a line that is too wide. You can turn Auto Fill mode on by doing M-x auto-fill-mode<Return>. When the mode is on, you can turn it off again by doing M-x auto-fill-mode<Return>. If the mode is off, this command turns it on, and if the mode is on, this command turns it off. We say that the command "toggles the mode". >> Type M-x auto-fill-mode<Return> now. Then insert a line of "asdf " over again until you see it divide into two lines. You must put in spaces between them because Auto Fill breaks lines only at spaces. The margin is usually set at 70 characters, but you can change it with the C-x f command. You should give the margin setting you want as a numeric argument. >> Type C-x f with an argument of 20. (M-20 C-x f). Then type in some text and see XEmacs fill lines of 20 characters with it. Then set the margin back to 70 using C-x f again. If you make changes in the middle of a paragraph, Auto Fill mode does not re-fill it for you. To re-fill the paragraph, type M-q (META-q) with the cursor inside that paragraph. >> Move the cursor into the previous paragraph and type M-q. * SEARCHING ----------- XEmacs can do searches for strings (these are groups of contiguous characters or words) either forward through the text or backward through it. Searching for a string is a cursor motion command; it moves the cursor to the next place where that string appears. The XEmacs search command is different from the search commands of most editors, in that it is "incremental". This means that the search happens while you type in the string to search for. The command to initiate a search is C-s for forward search, and C-r for reverse search. BUT WAIT! Don't try them now. When you type C-s you'll notice that the string "I-search" appears as a prompt in the echo area. This tells you that XEmacs is in what is called an incremental search waiting for you to type the thing that you want to search for. <Return> terminates a search. >> Now type C-s to start a search. SLOWLY, one letter at a time, type the word 'cursor', pausing after you type each character to notice what happens to the cursor. Now you have searched for "cursor", once. >> Type C-s again, to search for the next occurrence of "cursor". >> Now type <Backspace> four times and see how the cursor moves. >> Type <Return> to terminate the search. Did you see what happened? XEmacs, in an incremental search, tries to go to the occurrence of the string that you've typed out so far, highlighting it for your convenience. To go to the next occurrence of 'cursor' just type C-s again. If no such occurrence exists XEmacs beeps and tells you the search is currently "failing", C-g would also terminate the search. NOTE: On some older TTY connections, typing C-s will freeze the screen and you will see no further output from XEmacs. This indicates that an operating system "feature" called "flow control" is intercepting the C-s and not letting it get through to XEmacs. To unfreeze the screen, type C-q. Then see the section "Spontaneous Entry to Incremental Search" in the XEmacs manual for advice on dealing with this "feature". If you are in the middle of an incremental search and type <Backspace>, you'll notice that the last character in the search string is erased and the search backs up to the last place of the search. For instance, suppose you have typed "c", to search for the first occurrence of "c". Now if you type "u", the cursor will move to the first occurrence of "cu". Now type <Backspace>. This erases the "u" from the search string, and the cursor moves back to the first occurrence of "c". If you are in the middle of a search and type a control or meta character (with a few exceptions--characters that are special in a search, such as C-s and C-r), the search is terminated. The C-s starts a search that looks for any occurrence of the search string AFTER the current cursor position. If you want to search for something earlier in the text, type C-r instead. Everything that we have said about C-s also applies to C-r, except that the direction of the search is reversed. * MULTIPLE "WINDOWS" (I.E. PANES) --------------------------------- One of the nice features of XEmacs is that you can split the current frame (i.e. window-system window) into more than one pane, or "window" in XEmacs parlance. >> Move the cursor to this line and type M-0 C-l (that's zero, not Oh, and CONTROL-L, not CONTROL-1). >> Now type C-x 2 which splits the frame into two windows. Both windows display this tutorial. The cursor stays in the top window. >> Type M-<Next> to scroll the bottom window. (C-M-v on TTY's. If you do not have a real META key, type ESC C-v.) >> Type C-<Tab> to move the cursor to the bottom window. (Use C-x o -- "o" for "other" -- on TTY's.) >> Use <Next> and <Prior> in the bottom window to scroll it. Keep reading these directions in the top window. >> Type C-<Tab> again to move the cursor back to the top window. The cursor in the top window is just where it was before. You can keep using C-<Tab> to switch between the windows. Each window has its own cursor position, but only one window actually shows the cursor. All the ordinary editing commands apply to the window that the cursor is in. We call this the "selected window". If you have more than two windows, C-<Tab> cycles between them, and C-Sh-<Tab> (i.e. CONTROL-SHIFT-TAB) in the opposite direction. (There is no TTY equivalent for C-Sh-<Tab>.) The commands M-<Prior> and M-<Next> are very useful when you are editing text in one window and using the other window just for reference. You can keep the cursor always in the window where you are editing, and scroll forward or back through the other window with these commands. On TTY's, use C-M-v in place of M-<Next>, and there's no equivalent of M-<Prior>. C-M-v is an example of a CONTROL-META character. If you have a real META key, you can type C-M-v by holding down both CONTROL and META while typing v. It does not matter whether CONTROL or META "comes first," because both of these keys act by modifying the characters you type. If you do not have a real META key, and you use ESC instead, the order does matter: you must type ESC followed by CONTROL-v, because CONTROL-ESC v will not work. This is because ESC is a character in its own right, not a modifier key. >> Type C-x 1 (in the top window) to get rid of the bottom window. (If you had typed C-x 1 in the bottom window, that would get rid of the top one. Think of this command as "Keep just one window--the window I am already in.") You do not have to display the same buffer in both windows. If you use C-x C-f to find a file in one window, the other window does not change. You can find a file in each window independently. Here is another way to use two windows to display two different things: >> Type C-x 4 f followed by the name of one of your files. End with <Return>. See the specified file appear in the bottom window. The cursor goes there, too. >> Type C-<Tab> to go back to the top window, and C-x 1 to delete the bottom window. * MULTIPLE "FRAMES" (I.E. WINDOW-SYSTEM WINDOWS) ------------------------------------------------ On window systems, you can also create multiple "frames", or window-system windows. These exist independently of each other at the top level, just like separate programs. (There is no support for the MS Windows feature called MDI, or Multiple Document Interface, where multiple overlapping child windows exist inside of a single top-level window.) The commands for frames are similar to those for windows, but begin with "C-x 5". >> Type C-x 5 2 to create a new frame. >> Move the mouse into it, and click. (On X Windows, you may not need to click; this depends on the window manager.) >> Scroll up or down. Note that, just like for XEmacs windows, two frames can be showing the same buffer but in different positions. >> Type C-x 2. Note that each frame can have separate windows, independently of other frames. >> Type C-x 5 o (or Alt-Tab under MS Windows) to go back to the first frame. >> Type C-x 5 0 to kill the old frame. >> Note that we're still here! XEmacs will not exit until all frames are deleted, no matter what order they were created in. >> Type C-x 1 to get back to one window. You can also use C-x 5 f to open a file in a new frame, just like C-x 4 f opens a file in a new window in the same frame. * RECURSIVE EDITING LEVELS -------------------------- Sometimes you will get into what is called a "recursive editing level". This is indicated by square brackets in the mode line, surrounding the parentheses around the major mode name. For example, you might see [(Fundamental)] instead of (Fundamental). To get out of the recursive editing level, use the all-purpose escape mechanism mentioned earlier: ESC ESC. (Remember, it's ESC ESC ESC on TTY's.) You can also use it for eliminating extra windows, canceling a selection, and getting out of the minibuffer. >> Type M-x to get into a minibuffer; then type ESC ESC to get out. You cannot use C-g to get out of a recursive editing level. This is because C-g is used for canceling commands and arguments WITHIN the recursive editing level. * GETTING MORE HELP ------------------- In this tutorial we have tried to supply just enough information to get you started using XEmacs. There is so much available in XEmacs that it would be impossible to explain it all here. However, you may want to learn more about XEmacs since it has many other useful features. XEmacs provides commands for reading documentation about XEmacs commands. These "help" commands all start with the character CONTROL-h, which is called "the Help character". To use the Help features, type the C-h character, and then a character saying what kind of help you want. If you are REALLY lost, type C-h ? ? and XEmacs will tell you what kinds of help it can give. If you have typed C-h and decide you do not want any help, just type C-g to cancel it. (Note for TTY users: Some sites change the meaning of the character C-h. They really should not do this as a blanket measure for all users, so you have grounds to complain to the system administrator. Meanwhile, if C-h does not display a message about help at the bottom of the screen, try typing the F1 key or M-? instead.) The most basic HELP feature is C-h c. Type C-h, the character c, and a command character or sequence; then XEmacs displays a very brief description of the command. >> Type C-h c <Up>. The message should be something like up runs the command previous-line This tells you the "name of the function". Function names are used mainly for customizing and extending XEmacs. But since function names are chosen to indicate what the command does, they can serve also as very brief documentation--sufficient to remind you of commands you have already learned. Multi-character commands such as C-x C-s and <ESC>v are also allowed after C-h c. To get more information about a command, use C-h k instead of C-h c. >> Type C-h k <Up>. This displays the documentation of the function, as well as its name, in an XEmacs window. When you are finished reading the output, type q to get rid of the help text. Here are some other useful C-h options: C-h f Describe a function. You type in the name of the function. >> Try typing C-h f previous-line<Return>. This displays all the information XEmacs has about the function which implements the <Up> command. A similar command C-h v displays the documentation of variables whose values you can set to customize XEmacs behavior. You need to type in the name of the variable when XEmacs prompts for it. C-h a Hyper Apropos. Type in a keyword and XEmacs will list all the functions and variables whose names contain that keyword. For commands that can be invoked with META-x, an asterisk will be displayed to the left. >> Type C-h a newline<Return>. This displays a list of all functions and variables with "newline" in their names. Press <Return> or click the middle mouse button to find out more about a function or variable. Type `q' to exit hyper-apropos. C-h i Read On-line Manuals (a.k.a. Info). This command puts you into a special buffer called `*info*' where you can read on-line manuals for the packages installed on your system. Type m xemacs <Return> to read the XEmacs manual. If you have never before used Info, type ? and XEmacs will take you on a guided tour of Info mode facilities. Once you are through with this tutorial, you should consult the XEmacs Info manual as your primary documentation. * CONCLUSION ------------ Remember, to exit XEmacs permanently use the menu item "File/Exit XEmacs", or type C-x C-c. On TTY's, to temporarily exit to a shell, so that you can come back in, use C-z. This tutorial is meant to be understandable to all new users, so if you found something unclear, don't sit and blame yourself - complain! COPYRIGHTS, COPYING, ORIGINS ---------------------------- Copyright (c) 1985, 1996 Free Software Foundation. Copyright (c) 2001 Ben Wing. This tutorial is synched with FSF 21.0.106. This tutorial descends from a long line of Emacs tutorials starting with the one written by Stuart Cracraft for the original Emacs. Ben Wing updated the tutorial for X Windows. Martin Buchholz and Hrvoje Niksic added more corrections for XEmacs. Ben Wing later synched up to FSF 21.0.105 and rehashed many sections to match the current XEmacs norms. This version of the tutorial, like XEmacs, is copyrighted, and comes with permission to distribute copies on certain conditions: Permission is granted to anyone to make or distribute verbatim copies of this document as received, in any medium, provided that the copyright notice and permission notice are preserved, and that the distributor grants the recipient permission for further redistribution as permitted by this notice. Permission is granted to distribute modified versions of this document, or of portions of it, under the above conditions, provided also that they carry prominent notices stating who last altered them. The conditions for copying XEmacs itself are more complex, but in the same spirit. Please read the file COPYING and then do give copies of XEmacs to your friends. Help stamp out software obstructionism ("ownership") by using, writing, and sharing free software! Copyright (c) 1985,96,97 Free Software Foundation, Inc; See end for conditions. Emacs. Prvo berilo. Ukazi v Emacsu v splo¹nem vkljuèujejo tipki CONTROL (vèasih oznaèeni CTRL ali CTL) in META (vèasih oznaèena EDIT ali ALT). Namesto, da bi ju vedno izpisali s celim imenom, bomo uporabili naslednji okraj¹avi: C-<chr> pomeni, da moramo dr¾ati pritisnjeno tipko CONTROL, ko vtipkamo znak <chr>. Oznaka C-f tako pomeni: dr¾imo pritisnjeno tipko CONTROL in pritisnemo tipko f. M-<chr> pomeni, da moramo dr¾ati pritisnjeno tipko META, EDIT ali ALT, ko vtipkamo znak <chr>. Èe na tipkovnici ni tipk META, EDIT ali ALT, pritisnemo tipko ESC, jo spustimo in zatem pritisnemo tipko <chr>. Tipko ESC bomo oznaèevali z <ESC>. Pomembno: Emacs zapustimo z ukazom C-x C-c (dva znaka). V uèbeniku so vaje, s katerimi preskusite nove ukaze. Oznaèujeta jih znaka ,>>` ob levem robu. Primer: <<help-with-tutorial napolni preostanek s praznimi vrsticami>> >> Vtipkajte zdaj ukaz C-v (View next screen, Prika¾i naslednji zaslon), da se premaknete na naslednji zaslon (kar poskusite, pritisnite hkrati kontrolno tipko in V). Od zdaj naprej boste morali to napraviti sami vsakiè, ko pridete do konca zaslona. Ste opazili, da sta se dve vrstici s prej¹njega zaslona ponovili? Ta kontinuiteta olaj¹a branje pri skakanju s strani na stran. Prva stvar, ki si jo morate zapomniti, je, kako se premikate po datoteki. Zdaj ¾e veste, da se premaknete za cel zaslon naprej z ukazom C-v. Za cel zaslon nazaj pa se premaknete z ukazom M-v (pritisnite tipko META in jo dr¾ite ter pritisnite tipko v, ali pa pritisnite in spustite <ESC> ter zatem pritisnite tipko v, èe tipke META, EDIT ali ALT na va¹i tipkovnici ni). >> Nekajkrat pritisnite M-v in C-v, da vidite, kako ukaza delujeta. * POVZETEK ---------- Za pregled celega zaslona besedila so uporabni naslednji ukazi: C-v Premik se za cel zaslon naprej M-v Premik se za cel zaslon nazaj C-l Cel zaslon premaknemo tako, da je zdaj po vertikali centriran okoli besedila, kjer se nahaja kazalèek (znak v C-l je èrka L, ne ¹tevka 1) >> Poi¹èite kazalèek na zaslonu in si zapomnite besedilo okoli njega. Vtipkajte C-l. Ponovno poi¹èite kazalèek. Besedilo okoli njega je ostalo isto. * PREMIKANJE KAZALÈKA --------------------- Premiki za celo stran naprej in nazaj so sicer uporabni, ampak kako pa pridemo do izbranega mesta na zaslonu? Naèinov je veè. Najosnovnej¹i je uporaba ukazov C-p, C-b, C-f in C-n. Ti po vrsti premaknejo kazalèek v prej¹njo vrstico, znak nazaj, znak naprej, in v naslednjo vrstico. Grafièno prikazano: prej¹nja vrstica, C-p : : nazaj, C-b .... trenutni polo¾aj kazalèka .... naprej, C-f : : naslednja vrstica, C-n >> S pritiski na C-n ali C-p premaknite kazalèek v sredinsko vrstico na diagramu zgoraj. Zatem pritisnite C-l. S tem diagram postavite na sredino zaslona. V angle¹èini ima izbor tipk nazoren pomen. P kot ,previous` (prej¹nji), N kot ,next` (naslednji), B kot ,backward` (nazaj) in F kot ,forward` (naprej). To so osnovni ukazi za premikanje kazalèka in uporabljali jih boste VES ÈAS. Èim prej se jih nauèite, tem bolje. >> Nekajkrat pritisnite C-n, da pride kazalèek do te vrstice. >> Z nekaj C-f se pomaknite na desno na sredo vrstice, nato pa nekajkrat pritisnite C-p. Opazujte, kaj se dogaja s kazalèkom na sredini vrstice. Vsaka vrstice v besedilu je zakljuèena z znakom za novo vrstico (angl. Newline). Ta loèuje vrstico v besedilu od naslednje. Tudi zadnja vrstica v datoteki mora biti zaljuèena z znakom za novo vrstico (èeprav tega Emacs ne zahteva). >> Poskusite ukaz C-b, ko je kazalèek na zaèetku vrstice. Kazalèek se mora premakniti na konec prej¹nje vrstice. To je zato, ker se je ravnokar premaknil prek znaka za konec vrstice. Ukaz C-f premika kazalèek prek znaka za novo vrstico enako kot C-b. >> Poskusite ¹e nekajkrat pritisniti C-b, da dobite obèutek za premikanje kazalèka. Potem nekajkrat poskusite C-f, da pridete do konca vrstice. ©e enkrat pritisnite C-f, da skoèite v naslednjo vrstico. Ko s kazalèkom dose¾ete zgornji ali spodnji rob zaslona, se besedilo toliko premakne, da kazalèek ostane na zaslonu. V angle¹èini se temu pravi ,,scrolling``. To omogoèa, da lahko premaknemo kazalèek na katerokoli mesto v besedilu, a vseeno ostanemo na zaslonu. >> Poskusite kazalèek pripeljati s C-n èisto do dna zaslona in si oglejte, kaj se zgodi. Èe se vam zdi premikanje po en znak prepoèasno, se lahko premikate za celo besedo. M-f (Meta-f) premakne kazalèek za eno besedo naprej, M-b pa za besedo nazaj. >> Poskusite nekajkrat M-f in M-b. Èe je kazalèek sredi besede, ga M-f prestavi na konec besede. Èe je v belini med besedami, ga M-f premakne na konec naslednje besede. M-b deluje podobno, a v nasprotni smeri. >> Nekajkrat poskusite M-f in M-b, vmes pa ¹e nekaj C-f in C-b. Opazujte uèinke M-f in M-b, ko je kazalèek sredi besede ali med besedami. Ste opazili paralelo med C-f in C-b na eni strani ter M-f in M-b na drugi? V Emacsu se dostikrat ukazi Meta nana¹ajo na operacije nad enotami jezika (besede, stavki, odstavki), medtem ko se ukazi Control nana¹ajo na operacije, neodvisne od zvrsti besedila (znaki, vrstice ipd.). Podobna zveza je tudi med vrsticami in stavki: ukaza C-a in C-e premakneta kazalèek na zaèetek oz. konec vrstice, M-a in M-e pa na zaèetek oz. konec stavka. >> Poskusite nekaj ukazov C-a, potem pa nekaj ukazov C-e. Poskusite nekaj ukazov M-a, potem pa nekaj ukazov M-e. Ste opazili, da ponovljeni C-a ne napravijo niè, ponovljeni M-a pa se premikajo naprej? Èeprav se ne obna¹ata enako, pa je vendar obna¹anje enega in drugega po svoje naravno. Polo¾aju kazalèka na zaslonu pravimo tudi ,,point``, toèka. Parafrazirano: kazalèek ka¾e na zaslonu, kje je toèka v besedilu. Povzetek preprostih ukazov za premikanje kazalèka, vkljuèno s premiki po besedo in stavek: C-f Premik za znak naprej C-b Premik za znak nazaj M-f Premik za besedo naprej M-b Premik za besedo nazaj C-n Premik v naslednjo vrstico C-p Premik v prej¹njo vrstico C-a Premik na zaèetek vrstice C-e Premik na konec vrstice M-a Premik na zaèetek stavka M-e Premik na konec stavka >> Za vajo nekajkrat poskusite vsakega od teh ukazov. To so najpogosteje uporabljani ukazi. ©e dva pomembna ukaza za premikanje kazalèka sta M-< (Meta-manj¹i od), ki ga premakne na zaèetek datoteke, in M-> (Meta-veèji od), ki ga premakne na konec datoteke. Na ameri¹kih tipkovnicah najdete znak < nad vejico in morate pritisniti tipko Shift, da pridete do njega. Z ukazom M-< je enako - prav tako morate pritisniti tipko Shift, sicer moste izvedli drug ukaz, Meta-vejica. Na na¹ih tipkovnicah sta oba znaka na isti tipko, in za ukaz M-> morate pritisniti ¹e tipko Shift. >> Poskusite zdaj M-<, skok na zaèetek tega uèbenika. Potem se vrnite nazaj z zaporednimi C-v. >> Poskusite zdaj M->, skok na konec tega uèbenika. Potem se vrnite nazaj z zaporednimi M-v. Èe ima va¹a tipkovnica kurzorske tipke, lahko premikate kazalèek po zaslonu tudi z njimi. Vseeno priporoèamo, da se privadite ukazov C-b, C-f, C-n in C-p, in to iz treh razlogov. Prviè, delujejo na èisto vseh terminalih. Drugiè, z nekaj prakse v Emacsu boste opazili, da je tipkanje ukazov s Control hitrej¹e od tipkanja s kurzorskimi tipkami, ker ni treba ves èas premikati desnice s tipkovnice na kurzorske tipke in nazaj. In tretjiè, ko se enkrat navadite teh ukazov s Control, se boste enostavneje nauèili tudi bolj zapletenih ukazov za premikanje kazalèka. Veèini ukazov v Emacsu lahko podamo ¹tevilèni argument; najveèkrat ta pove, kolikokrat zapovrstjo naj se ukaz izvede. Veèkratno ponovitev ukaza izvedemo tako, da najprej vtipkamo C-u, zatem ¹tevilo, kolikokrat naj se ukaz ponovi, in nazadnje ¾eljeni ukaz. Èe ima va¹a tipkovnica tipko META (ali EDIT ali ALT), lahko izpustite ukaz C-u in namesto tega vtipkate ¹tevilo ponovitev, medtem ko dr¾ite pritisnjeno tipko META. Druga metoda je sicer kraj¹a, priporoèamo pa prvo, ker deluje na vseh terminalih. Tak¹en ¹tevilèni argument je ,,prefiksni`` argument, ker vnesemo argument pred ukazom, na katerega se nana¹a. Primer: C-u 8 C-f premakne kazalèek za osem znakov naprej. >> Poskusite s primernim argumentom za ¹tevilo ponovitev ukaza C-n ali C-p priti èim bli¾e tej vrstici v enem samem skoku. Veèina ukazov, ne pa vsi, uporablja ¹tevilèni argument kot ¹tevilo ponovitev ukaza. Nekateri ukazi (nobeden od tistih, ki smo si jih ogledali do zdaj) ga uporabljajo kot stikalo: s podanim prefiksnim argumentom napravi ukaz nekaj drugega kot obièajno. Ukaza C-v in M-v sta tudi izjemi, a drugaèni. Èe jima podamo argument, premakneta zaslon za navedeno ¹tevilo vrstic, ne pa zaslonov. Ukaz C-u 4 C-v, na primer, premakne zaslon navzgor za 4 vrstice. >> Poskusite zdaj C-u 8 C-v To bi moralo zaslon premakniti navzgor za osem vrstic. Èe bi ga radi premaknili nazaj, poskusite M-v z istim argumentom. Èe uporabljate X Windows, imate verjetno ob levem robu Emacsovega okna navpièno pravokotno ploskev, imenovano drsnik. Pogled na besedilo lahko premikate tudi tako, da z mi¹ko kliknete na drsnik. >> Postavite kazalec na vrh oznaèenega obmoèja na drsniku in pritisnite srednji gumb na mi¹ki. To bi moralo premakniti besedilo na mesto, doloèeno s tem, kako visoko ali nizko na drsnik ste kliknili. >> Medtem ko dr¾ite srednji gumb pritisnjen, premikajte mi¹ko gor in dol. Vidite, kako se premika besedilo v Emacsovem oknu, ko premikate mi¹ko? * ÈE SE EMACS OBESI ------------------- Èe se Emacs preneha odzivati na va¹e ukaze, ga lahko varno prekinete z ukazom C-g. Z njim lahko prekinete ukaze, za katere bi trajalo predolgo, da bi se izvedli. Isti ukaz, C-g, lahko uporabite tudi, da preklièete ¹tevilèni argument, ali pa zaèetek ukaza, ki ga ne ¾elite izvesti. >> Vtipkajte C-u 100, s èimer ste izbrali ¹tevilèni argument 100, zatem pa vtipkajte C-g. Vtipkajte zdaj C-f. Kazalèek se je premaknil le za en znak, ker ste ¹tevilèni argument vmes preklicali s C-g. Tudi èe ste po nesreèi vtipkali <ESC>, se ga lahko znebite s C-g. * ONEMOGOÈENI UKAZI ------------------- Nekaj ukazov v Emacsu je namenoma ,,onemogoèenih``, da bi jih zaèetniki ne izvedli po nesreèi. Èe vtipkate tak onemogoèen ukaz, se bo na zaslonu pojavilo novo okno z obvestilom, kateri ukaz ste sku¹ali izvesti, in vas vpra¹alo, èe ga res ¾elite izvesti. Èe v resnici ¾elite poskusiti ukaz, pritisnite preslednico kot odgovor na vpra¹anje. Normalno verjetno ukaza ne ¾elite izvesti, zato na vpra¹anje odgovorite z ,n`. >> Vtipkajte <ESC> : (ki je onemogoèen ukaz), zatem odgovorite n. * OKNA ------ Emacs lahko prika¾e veè oken in v vsakem svoje besedilo. Kasneje bomo razlo¾ili, kako uporabljamo veè oken hkrati. Zaenkrat bomo povedali le, kako se znebite dodatnih oken, ki jih lahko odpre vgrajena pomoè ali pa izpis kak¹nega drugega programa. Preprosto je: C-x 1 Eno okno (torej, zaprimo vsa ostala). To je Ctrl-x, ki mu sledi ¹tevka 1. Ukaz C-x 1 raztegne èez cel zaslon okno, v katerem se nahaja kazalèek, ostala pa zapre. >> Premaknite kazalèek do te vrstice in vtipkajte C-u 0 C-l >> Vtipkajte Ctrl-h k Ctrl-f. Vidite, kako se je to okno skrèilo in odstopilo prostor oknu, ki pojasnjuje ukaz Ctrl-f? >> Vtipkajte C-x 1 in spodnje okno se bo zaprlo. Za razliko od ukazov, ki smo se jih nauèili do zdaj, je ta ukaz sestavljen iz dveh znakov. Zaène se z znakom Control-x. Cela vrsta ukazov se zaène enako, in mnogi od njih zadevajo delo z datotekami, delovnimi podroèji in podobnim. Vsem tem ukazom je skupno, da se zaènejo s Control-x, ki mu sledi ¹e en, dva ali trije znaki. * VRIVANJE IN BRISANJE ---------------------- Èe ¾elite v obstojeèe besedilo vriniti novo, preprosto premaknite kazalèek na ¾eljeno mesto in zaènite tipkati. Znake, ki jih lahko vidite, na primer A, 7, * in podobno, razume Emacs kot del besedila in jih takoj vrine. S pritiskom na Return (ali Enter) vrinete znak za skok v novo vrstico. Zadnji vtipkani znak lahko izbri¹ete s pritiskom na tipko <Delete>. Na nekaterih tipkovnicah je oznaèena z <Del>. Ponekod (ne pa povsod!) slu¾i za brisanje tipka <Backspace>. Splo¹no <Delete> pobri¹e znak neposredno pred trenutnim polo¾ajem kazalèka. >> Vtipkajte zdaj nekaj znakov in jih zatem s tipko <Delete> pobri¹ite. Niè naj vas ne skrbi, èe se je ta vrstica spremenila. Izvirnika tega uèbenika ne boste pokvarili -- tole je samo va¹a osebna kopija. Ko vrstica postane predolga za zaslon, se ,,nadaljuje`` v naslednji vrstici na zaslonu. Obrnjena po¹evnica (znak ,\`) ob desnem robu oznaèuje vrstico, ki se nadaljuje v naslednji zaslonski vrstici. >> Zdaj zaènite tipkati besedilo, dokler ne dose¾ete desnega roba, in ¹e naprej. Opazili boste, da se pojavi znak za nadaljevanje. >> S tipko <Delete> pobri¹ite toliko znakov, da vrstica ne sega veè èez ¹irino zaslona. Znak za nadaljevanje v naslednji vrstici je izginil. Znak za novo vrstico lahko pobri¹emo enako kot vsak drug znak. S tem, ko pobri¹emo znak za novo vrstico, zdru¾imo vrstici v eno samo. Èe bo nova vrstica predolga, da bi cela pri¹la na zaslon, bo razdeljena v veè zaslonskih vrstic. >> Premaknite kazalèek na zaèetek vrstice in pritisnite <Delete>. To zdru¾i vrstico s prej¹njo. >> Pritisnite <Return>. S tem ste ponovno vrinili znak za skok v novo vrstico, ki ste ga malo prej zbrisali. Spomnimo se, da lahko za veèino ukazov v Emacsu doloèimo, naj se izvedejo veèkrat zaporedoma; to vkljuèuje tudi vnos teksta. Ponovitev obièajnega znaka ga veèkrat vrine v besedilo. >> Poskusite zdaj tole: da vnesete osem zvezdic, vtipkajte C-u 8 * Zdaj ste se nauèili najpreprostej¹i naèin, da v Emacsu nekaj natipkate in popravite. Bri¹ete lahko tudi besede ali vrstice. Tu je povzetek ukazov za brisanje: <Delete> pobri¹e znak tik pred kazalèkom (levo od oznake za kazalèek) C-d pobri¹e znak tik za kazalèkom (,pod` oznako za kazalèek) M-<Delete> pobri¹e besedo tik pred kazalèkom M-d pobri¹e besedo tik za kazalèkom C-k zavr¾e besedilo desno od kazalèka do konca vrstice M-k zavr¾e besedilo od polo¾aja kazalèka do konca stavka Èrka ,d` je iz angle¹ke besede ,delete` (pobrisati), èrka ,k` pa iz besede ,kill` (pobiti). Ste opazili, da <Delete> in C-d na eni, ter M-<Delete> in M-d na drugi strani nadaljujeta paralelo, ki sta jo zaèela C-f in M-f (<Delete> pravzaprav ni kontrolni znak, kar pa naj nas ne moti). C-k in M-k sta v enakem sorodu s C-e in M-e: prvi deluje na vrstice, drugi na stavke. Kadarkoli pobri¹ete kaj veè kot en sam znak naenkrat, si Emacs za vsak primer zapomni, kaj ste zavrgli, in lahko zavr¾eno vrnete (angl. ,,yank`` -- potegniti). Besedilo, ki smo ga zavrgli, lahko vrinemo nazaj na isto mesto ali kam drugam. Lahko ga vrinemo tudi veèkrat, in tako napravimo veè kopij. Ukaz za vraèanje zavr¾enega besedila je C-y. Razlika med tem, èe zavr¾ete cel odstavek besedila (angl. ,,kill``, pobiti) ali pa èe pobri¹ete znak (angl. ,,delete``), je ta, da lahko prvega vrnete nazaj z ukazom C-y, drugega pa ne. Na splo¹no ukazi, ki lahko povzroèijo veliko ¹kode (pobri¹ejo veliko besedila), shranijo pobrisano besedilo; tisti, ki pobri¹ejo samo posamezni znak, ali samo prazne vrstice in presledke, pa ne. >> Postavite kazalèek na zaèetek neprazne vrstice. Pritisnite C-k, da pobri¹ete vsebino vrstice. >> ©e enkrat pritisnite C-k. To pobri¹e ¹e znak za novo vrstico. Ste opazili, da prvi C-k pobri¹e vsebino vrstice, naslednji C-k pa ¹e vrstici samo, s èimer se vse besedilo pod biv¹o vrstico premakne za eno vrstico navzgor? Ukaz C-k obravnava ¹tevilèni argument malo drugaèe: pobri¹e toliko in toliko vrstic z vsebinami vred. To ni zgolj ponovitev. C-u 2 C-k pobri¹e dve polni vrstici besedila, kar je nekaj drugega, kot èe dvakrat vtipkate C-k. Besedilo, ki ste ga prej pobrisali, je shranjeno, in ga lahko povrnete tja, kjer je trenutno kazalèek, z ukazom C-y. >> Poskusite z ukazom C-y povrniti pobrisano besedilo. Ukaz C-y si predstavljajte, kot da potegnete nazaj nekaj, kar vam je nekdo odnesel. Èe ste uporabili veè zaporednih ukazov C-k, je vse pobrisano besedilo shranjeno skupaj, in en sam C-y bo vrnil vse tako pobrisane vrstice. >> Poskusite, nekajkrat vtipkajte C-k. Zdaj pa vrnimo pobrisano besedilo: >> Vtipkajte C-y. Zdaj pa premaknite kazalèek za nekaj vrstic navzdol in ¹e enkrat vtipkajte C-y. Vidite zdaj, kako se kopira dele besedila? Kaj pa, èe ste pobrisali nekaj besedila, ki bi ga radi vrnili, vendar ste za iskanim odlomkom pobrisali ¹e nekaj? C-y vrne samo nazadnje pobrisan odlomek. Vendar tudi prej¹nje besedilo ni izgubljeno. Do njega lahko pridete z ukazom M-y. Ko ste vrnili nazadnje zbrisano besedilo s C-y, pritisnite M-y, ki ga zamenja s predzanje pobrisanim besedilom. Vsak naslednji M-y prika¾e ¹e eno prej. Ko ste konèno pri¹li do iskanega besedila, ni treba napraviti niè posebnega, da bi ga obdr¾ali. Preprosto nadaljujte z urejanjem, in vrnjeno besedilo bo ostalo, kamor ste ga odlo¾ili. Èe pritisnete M-y dovolj velikokrat, se boste vrnili na zaèete, torej spet na zadnje pobrisano besedilo. >> Pobri¹ite vrstico, premaknite se nekam drugam, in pobri¹ite ¹e eno vrstico. Z ukazom C-y dobite nazaj to drugo vrstico. Z ukazom M-y pa jo zamenjate s prvo vrstico. Ponovite ukaz M-y ¹e nekajkrat in si oglejte, kaj dobite na zaslon. Ponavljajte ga, dokler se ne prika¾e ponovno nazadnje pobrisana vrstica, in ¹e naprej. Èe ¾elite, lahko tudi ukazu M-y podate pozitivno ali negativno ¹tevilo ponovitev. * PREKLIC UKAZA (UNDO) ---------------------- Èe ste besedilo spremenili, a ste se kasneje premislili, lahko besedilo vrnete v prvotno stanje z ukazom Undo, C-x u. Normalno vrne C-x u zadnjo spremembo besedila; èe ukaz ponovimo, preklièemo ¹e predzadnjo spremembo, in vsaka nadaljnja ponovitev se¾e ¹e eno spremembo globlje v zgodovino. Emacs hrani bolj ali manj celotno zgodovino na¹ih ukazov, z dvema izjemama: ukazov, ki niso napravili nobene spremembe v besedilu (npr. premik kazalèka), ne shranjuje, in zaporedje do 20 vrinjenih znakov shrani kot en sam ukaz. Slednje prihrani nekaj ukazov C-x u, ki bi jih morali vtipkati. >> Pobri¹ite to vrstico z ukazom C-k, potem jo priklièite nazaj s C-x u. C-_ je alternativni ukaz za preklic zadnjega ukaza. Deluje enako kot s C-x u, ga je pa la¾je odtipkati, èe morate ukaz ponoviti veèkrat zaporedoma. Te¾ava z ukazom C-_ je, da na nekaterih tipkovnicah ni povsem oèitno, kako ga vtipkati, zato je podvojen ¹e kot C-x u. Na nekaterih terminalih moramo na primer vtipkati /, medtem ko dr¾imo pritisnjeno tipko CONTROL. Èe podamo ukazu C-_ ali C-x u numerièni argument, je to enako, kot èe bi ukaz roèno ponovili tolikokrat, kot pravi argument. * DATOTEKE ---------- Da bi bile spremembe v besedilu trajne, morate besedilo shraniti v datoteko. V nasprotnem primeru jih boste za vedno izgubili tisti hip, ko boste zapustili Emacs. Besedilo postavimo v datoteko tako, da na disku ,,poi¹èemo`` (angl. find) datoteko, preden zaènemo tipkati (pravimo tudi, da ,,obi¹èemo`` datoteko). Poiskati datoteko pomeni, da v Emacsu vidimo vsebino datoteke. To je bolj ali manj tako, kot da z Emacsom urejamo datoteko samo. Vendar pa spremembe ne postanejo trajne, dokler datoteke ne shranimo (angl. save) na disk. Tako imamo mo¾nost, da se izognemo temu, da bi nam na pol spremenjene datoteke le¾ale po disku, kadar tega ne ¾elimo. Ker pa Emacs ohrani izvorno datoteko pod spremenjenim imenom, lahko prvotno datoteko priklièemo nazaj celo ¹e potem, ko smo datoteko ¾e shranili na disk. V predzadnji vrstici na dnu zaslona vidite vrstico, ki se zaène in konèa z vezaji, in vsebuje niz znakov ,,--:-- TUTORIAL``. Ta del zaslona navadno vsebuje ime datoteke, ki smo jo obiskali. Zdajle je to ,,TUTORIAL``, va¹a delovna kopija uèbenika Emacsa. Ko boste poiskali kak¹no drugo datoteko, bo na tem mestu pisalo njeno ime. Posebnost ukaza za iskanje datoteke je, da moramo povedati, katero datoteko i¹èemo. Pravimo, da ukaz ,,prebere argument s terminala`` (v tem primeru je argument ime datoteke). Ko vtipkate ukaz C-x C-f (poi¹èi datoteko) vas Emacs povpra¹a po imenu datoteke. Kar vtipkate, se sproti vidi v vrstici na dnu zaslona. Temu delovnemu podroèju pravimo pogovorni vmesnik (minibuffer), kadar se uporablja za tovrstni vnos. Znotraj pogovornega vmesnika lahko uporabljate obièajne ukaze za urejanje, èe ste se na primer pri tipkanju zmotili. Sredi tipkanja imena datoteke (ali katerega koli drugega opravila v pogovornem vmesniku) lahko ukaz preklièete s C-g. >> Vtipkajte C-x C-f, zatem pa ¹e C-g. Zadnji ukaz od treh je zaprl pogovorni vmesnik in tudi preklical ukaz C-x C-f, ki je uporabljal pogovorni vmesnik. Konec z iskanjem datoteke. Ko ste dokonèali ime, ga vnesete s pritiskom na <Return>. S tem se po¾ene ukaz C-x C-f in poi¹èe iskano datoteko. Pogovorni vmesnik izgine, ko je ukaz izveden. Trenutek kasneje se vsebina datoteke pojavi na zaslonu. Zdaj lahko dopolnjujete, urejate ali kako drugaèe spreminjate vsebino. Ko ¾elite, da ostanejo spremembe trajne, izvedete ukaz: C-x C-s (shrani datoteko) Besedilo se s tem shrani iz pomnilnika raèunalnika na datoteko na disk. Ko prviè izvedete ta ukaz, se izvorna datoteka preimenuje, tako da ni izgubljena. Najdete jo pod novim imenom, ki se od starega razlikuje po tem, da ima na koncu pripet znak ,,~``. Ko je Emacs shranil datoteko, izpi¹e njeno ime. Shranjujte raje pogosteje kot ne, da v primeru, èe gre z raèunalnikom kaj narobe, ne izgubite veliko. >> Vtipkajte C-x C-s, s èimer boste shranili svojo kopijo tega uèbenika. Emacs bo v vrstici na dnu zaslona izpisal ,,Wrote ...TUTORIAL``. Opozorilo: na nekaterih sistemih bo ukaz C-x C-s zamrznil zaslon, in tako ne boste videli, da Emacs ¹e kaj izpi¹e. To je znak, da je operacijski sistem prestregel znak C-s in ga interpretiral kot znak za prekinitev toka podatkov, namesto da bi ga posredoval Emacsu. Zaslon ,,odmrznete`` z ukazom C-q. Èe je va¹ sistem eden takih, si za nasvet, kako re¹iti to nev¹eènost, oglejte razdelek ,,Spontaneous Entry to Incremental Search`` v priroèniku za Emacs. Poi¹èete lahko lahko ¾e obstojeèo datoteko, da si jo ogledate ali popravite, ali pa tudi datoteko, ki ¹e ne obstaja. To je naèin, kako z Emacsom ustvarimo novo datoteko: poi¹èite datoteko z izbranim imenom, ki bo sprva prazna, in zaènite pisati. Ko jo boste prviè shranili, bo Emacs ustvaril datoteko z vne¹enim besedilom. Od tod dalje delate na ¾e obstojeèi datoteki. * DELOVNA PODROÈJA ------------------ Tudi èe ste z ukazom C-x C-f poiskali in odprli drugo datoteko, prva ostane v Emacsu. Nanjo se vrnete tako, da jo ¹e enkrat ,,poi¹èete`` z ukazom C-x C-f. Tako imate lahko v Emacsu hkrati kar precej datotek. >> Ustvarite datoteko z imenom ,,foo`` tako, da vtipkate C-x C-f foo <Return>. Natipkajte nekaj besedila, ga po potrebi popravite, in shranite v datoteko ,,foo`` z ukazom C-x C-s. Ko ste konèali, se vrnite v uèbenik z ukazom C-x C-f TUTORIAL <Return>. Emacs hrani besedilo vsake datoteke v takoimenovanem ,,delovnem podroèju`` (angl. buffer). Ko poi¹èemo datoteko, Emacs ustvari zanjo novo delovno podroèje. Vsa obstojeèa delovna podroèja v Emacsu vidimo z ukazom: C-x C-b Seznam delovnih podroèij. >> Poskusite C-x C-b zdaj. Vidite, da ima vsako delovno podroèje svoje ime, pri nekaterih pa pi¹e tudi ime datoteke, katere vsebina se hrani v njem. Druga delovna podroèja pa ne pripadajo nobeni datoteki. Podroèje ,,*Buffer List*``, na primer, je ¾e eno takih. To delovno podroèje smo ustvarili ravnokar, ko smo pognali ukaz C-x C-b. VSAKO besedilo, ki ga vidite v katerem od Emacsovih oken, je vedno del kak¹nega delovnega podroèja. >> Z ukazom C-x 1 se znebite seznama delovnih podroèij. Èe ste spreminjali besedilo ene datoteke, potem pa poiskali drugo, to ne shrani spremeb v prvo datoteko. Te ostanejo znotraj Emacsa, na delovnem podroèju, ki pripada prvi datoteki. Ustvarjenje ali spreminjanje delovnega podroèja druge datoteke nima nobenega vpliva na podroèje prve. To je zelo uporabno, pomeni pa tudi, da potrebujemo udobno pot, da shranimo delovno podroèje prve datoteke. Nerodno bi bilo preklapljanje na prvo podroèje s C-x C-f, da bi shranili s C-x C-s. Namesto tega imamo: C-x s Shrani nekatera delovna podroèja Ukaz C-x poi¹èe delovna podroèja, katerih vsebina je bila spremenjena, odkar je bila zadnjiè shranjena na datoteko. Za vsako tako delovno podroèje C-x s vpra¹a, èe ga ¾elite shraniti. * RAZ©IRJEN NABOR UKAZOV ------------------------ ©e mnogo, mnogo je ukazov Emacsa, ki bi zaslu¾ili, da jih obesimo na razne kontrolne in meta znake. Emacs se temu izogne z ukazom X (iz angl. eXtend - raz¹iriti), ki uvede ukaz iz raz¹irjenega nabora. Dveh vrst je: C-x Znakovna raz¹iritev (angl. Character eXtend). Sledi mu en sam znak. M-x Raz¹iritev s poimenovanim ukazom. Sledi mu dolgo ime ukaza. Tudi ti ukazi so na splo¹no uporabni, ne uporabljamo pa jih tako pogosto kot tiste, ki ste se jih ¾e nauèili. Dva ukaza iz raz¹irjenega nabora ¾e poznamo: C-x C-f, s katerim poi¹èemo datoteko, in C-x C-s, s katerim datoteko shranimo. ©e en primer je ukaz, s katerim Emacsu povemo, da ¾elimo konèati z delom iz iziti iz Emacsa. Ta ukaz je C-x C-c (ne skrbite: preden konèa, Emacs ponudi, da shrani vse spremenjene datoteke). Z ukazom C-z Emacs zapustimo samo *zaèasno*, tako da lahko ob vrnitvi nadaljujemo z delom, kjer smo ostali. Na sistemih, ki to dopu¹èajo, ukaz C-z izide iz Emacsa v ukazno lupino, a ga ne konèa - èe uporabljate ukazno lupino C, se lahko vrnete z ukazom ,fg` ali splo¹neje z ukazom ,,%emacs``. Drugod ukaz C-z po¾ene sekundarno ukazno lupino, tako da lahko po¾enete kak¹en drug program in se kasneje vrnete v Emacs. V tem primeru pravzaprav Emacsa ne zapustimo. Ukaz ,,exit`` v ukazni lupini je navadno naèin, da zapremo sekundarno lupino in se vrnemo v Emacs. Ukaz C-x C-c uporabimo, èe se nameravamo odjaviti s sistema. To je tudi pravilen naèin za izhod iz Emacsa, èe je tega pognal program za delo s po¹to ali kak drug program, saj ta verjetno ne ve, kaj napraviti z zaèasno prekinjenim Emacsom. V vseh ostalih primerih pa, èe se ne nameravate odjaviti s sistema, uporabite C-z, in se vrnite v Emacs, ko bi radi spet urejali besedilo. Ukazov C-x je veliko. Zaenkrat smo spoznali naslednje: C-x C-f Poi¹èi datoteko. C-x C-s Shrani datoteko. C-x C-b Seznam delovnih podroèij. C-x C-c Konèaj Emacs. C-x u Preklic zadnjega ukaza. Poimenovani raz¹irjeni ukazi so ukazi, ki se uporabljajo ¹e bolj poredko, ali pa se uporabljajo samo v nekaterih naèinih dela. Eden takih je na primer ukaz replace-string, ki po vsem besedilu zamenja en niz znakov z drugim. Ko vtipkate M-x, se to izpi¹e v pogovornem vmesniku na dnu zaslona, Emacs pa èaka, da vtipkate ime ukaza, ki ga ¾elite priklicati; v tem primeru je to ,,replace-string``. Vtipkajte samo ,,repl s<TAB>`` in Emacs bo dopolnil ime. Ukaz vnesete s pritiskom na <Return>. Ukaz replace-string potrebuje dva argumenta -- niz, ki ga ¾elite zamenjati, in niz, s katerim bi radi zamenjali prvega. Vsakega posebej vnesete in zakljuèite s pritiskom na tipko Return. >> Premaknite kazalèek na prazno vrstico dve vrstici pod to, zatem vtipkajte M-x repl s<Return>zamenjala<Return>spremenila<Return>. Opazite, kako se je ta vrstica zamenjala? Vse besede z-a-m-e-n-j-a-l-a od tod do konca besedila ste nadomestili z besedo ,,spremenila``. * AVTOMATIÈNO SHRANJEVANJE -------------------------- Spremembe v datoteki, ki jih ¹e niste shranili na disk, so izgubljene, èe medtem denimo zmanjka elektrike. Da bi vas zavaroval pred tem, Emacs periodièno avtomatièno shrani vse datoteke, ki jih urejate. Avtomatièno shranjena datoteka se od izvorne razlikuje po znaku ,#` na zaèetku in koncu imena: èe se je va¹a datoteka imenovala ,,hello.c``, se avtomatièno shranjena datoteka imenuje ,,#hello.c#``. Ko normalno shranite datoteko, avtomatièno shranjena datoteka ni veè potrebna, in Emacs jo pobri¹e. Èe res pride do izgube podatkov v pomnilniku, lahko povrnete avtomatièno shranjeno besedilo tako, da normalno poi¹èete datoteko (pravo ime datoteke, ne ime avtomatièno shranjene datoteke), zatem pa vtipkate M-x recover file<Return>. Ko vas vpra¹a za potrditev, vtipkajte yes<Return> za nadaljevanje in povrnitev avtomatièno shranjenenih podatkov. * ODZIVNO PODROÈJE ------------------ Kadar Emacs opazi, da poèasi vtipkavate ukaz, odpre v zadnji vrstici na dnu zaslona odzivno podroèje in v njem sproti prikazuje natipkano. * STATUSNA VRSTICA ------------------ Vrstica nad odzivnim podroèjem je statusna vrstica. Ta ka¾e verjetno nekaj podobnega kot: --:** TUTORIAL (Fundamental)--58%---------------------- V njej so izpisani pomembni podatki o stanju Emacsa in besedilu, ki ga urejate. Zdaj ¾e veste, kaj pomeni ime datoteke -- to je datoteka, ki ste jo poiskali. Oznaka --NN%-- pomeni, da je nad vrhom zaslona ¹e NN odstotkov celotne datoteke. Èe je zaèetek datoteke na zaslonu, bo namesto --00%-- pisalo --Top--. Podobno bo pisalo --Bot--, èe je zadnja vrstica datoteke na zaslonu. Èe je datoteka, ki jo ogledujete, tako kratka, da gre vsa na en zaslon, pa bo pisalo --All--. Zvezdice na zaèetku vrstice pomenijo, da ste datoteko ¾e spreminjali. Tik po tem, ko ste odprli ali shranili datoteko, ni nobenih zvezdic, so samo èrtice. Del statusne vrstice znotraj oklepajev vam pove, v kak¹nem naèinu dela Emacs. Privzeti naèin je osnovni naèin (Fundamental), v katerem ste sedaj. Fundamental je eden od glavnih naèinov (angl. major mode). Emacs pozna veliko razliènih glavnih naèinov. Nekateri od njih so namenjeni pisanju programov, kot na primer Lisp, ali pisanju besedil, kot npr. Text. Naenkrat je lahko aktiven le en glavni naèin, njegovo ime pa je vedno izpisano v statusni vrstici, kjer zdaj pi¹e Fundamental. Glavni naèini lahko spremenijo pomen nekaterim ukazom. Obstajajo, denimo, ukazi za pisanje komentarjev v programu, in ker ima vsak programski jezik svoje predstave o tem, kako mora komentar izgledati, mora vsak glavni naèin vnesti komentarje drugaèe. Ker je vsak glavni naèin ime raz¹irjenega ukaza, lahko tako tudi izbiramo glavni naèin. Na primer, M-x fundamental-mode vas postavi v naèin Fundamental. Èe nameravate popravljati slovensko (ali angle¹ko) besedilo, kot je na primer tole, boste verjetno izbrali tekstovni naèin (Text). >> Vtipkajte M-x text mode<Return>. Ne skrbite, noben od ukazov, ki ste se jih nauèili, se s tem ne spremeni kaj dosti. Lahko pa opazite, da Emacs zdaj jemlje opu¹èaje za dele besed, ko se premikate z M-f ali M-b. V osnovnem naèinu jih je obravnaval kot meje med besedami. Glavni naèini navadno poèenjajo majhne spremembe, kot je ta: veèina ukazov ,,opravi isti posel``, vendar pa to poènejo na razlièen naèin. Dokumentacijo o trenutno aktivnem glavnem naèinu dobite z ukazom C-h m. >> Uporabite C-u C-v enkrat ali veèkrat, toliko, da bo ta vrstica blizu vrha zaslona. >> Vtipkajte C-h m, da vidite, v èem se tekstovni naèin (Text) razlikuje od osnovnega (Fundamental). >> Vtipkajte C-x 1, da umaknete dokumentacijo z zaslona. Glavnim naèinom pravimo glavni naèini zato, ker obstajajo tudi podnaèini (angl. minor modes). Podnaèini ne nadome¹èajo glavnih naèinom, ampak le spreminjajo njihovo obna¹anje. Podnaèine lahko aktiviramo ali deaktiviramo neodvisno od glavnega naèina in neodvisno od ostalih podnaèinov. Tako lahko ne uporabljate nobenega podnaèina, en podnaèin, ali kombinacijo veèih podnaèinov. Podnaèin, ki je zelo uporaben, posebno za pisanje besedil, je Auto Fill. Ko je vklopljen, Emacs med pisanjem avtomatièno deli vrstice na presledkih med besedami, tako da vrstice niso predolge. Vklopite ga lahko z ukazom M-x auto fill mode<return>. Ko je vklopljen, ga lahko izklopite z istim ukazom, M-x auto fill mode<return>. Z istim ukazom torej preklapljamo (angl. toggle) med vklopljenim in izklopljenim stanjem. >> Vtipkajte zdaj M-x auto fill mode. Potem zaènite tipkati "asdf asdkl sdjf sdjkf"... dokler ne opazite, da je Emacs razbil vrstico na dve. Med tipkanjem mora biti dovolj presledkov, saj Auto Fill prelamlja vrstice samo na presledkih. ©irina besedila je navadno postavljena na 70 znakov, kar pa lahko spremenite z ukazom C-x f. Novo ¹irino morate podati kot ¹tevilèni argument. >> Vtipkajte C-x f in argument 20. (C-u 2 0 C-x f). Zatem vtipkajte nekaj besedila in poglejte, èe bo Emacs res delil vrstice pri 20 znakih. Potem z ukazom C-x f postavite mejo nazaj na 70. Auto Fill deluje le, kadar pi¹ete novo besedilo, ne pa, kadar popravljate ¾e napisan odstavek. Tak odstavek lahko poravnate tako, da kazalèek premaknete nekam znotraj odstavka in uka¾ete M-q (Meta-q). >> Premaknite kazalèek v prej¹nji odstavek in izvedite M-q. * ISKANJE --------- Emacs lahko v besedilu poi¹èe niz znakov (zaporedje znakov ali besed), naprej ali nazaj po besedilu. Iskanje spada v skupino ukazov za premikanje kazalèka, saj premakne kazalèek na kraj v besedilu, kjer je na¹el iskani niz. Iskanje v Emacsu je morda nekoliko drugaèno od tistega, ki ste ga navajeni, in sicer je ,,inkrementalno``. To pomeni, da se iskanje odvija hkrati s tem, ko tipkate iskani niz. Ukaza za iskanje sta C-s za iskanje naprej po datoteki in C-r za iskanje nazaj po datoteki. POÈAKAJTE! Ne preizku¹ajte jih ¹e ta hip! Ko boste natipkali C-s, boste opazili niz ,,I-search`` kot pozivnik v pogovornem vmesniku. To vam pove, da je Emacs v inkrementalnem iskanju in vas èaka, da zaènete tipkati, kar i¹èete. <Return> zakljuèi iskanje. >> Pritisnite zdaj C-s. POÈASI, èrko za èrko, vtipkajte besedo ,,kazalèek``. Za vsako vtipkano èrko se ustavite in si oglejte, kaj se je zgodilo s kazalèkom. >> ©e enkrat pritisnite C-s, da poi¹èete naslednji ,,kazalèek``. >> ©estkrat pritisnite <Delete> in opazujte, kako se premika kazalèek. >> Konèajte iskanje s tipko <Return>. Ste videli, kaj se je zgodilo? Emacs pri inkrementalnem iskanju sku¹a poiskati niz, ki ste ga natipkali do tistega hipa. Da poi¹èete naslednje mesto, kjer se pojavi ,,kazalèek``, samo ¹e enkrat pritisnete C-s. Èe takega mesta ni, Emacs èivkne in vam sporoèi, da iskanje ni uspelo. Tudi C-g prekine iskanje. OPOZORILO: Na nekaterih sistemih bo s pritiskom na C-s ekran zmrznil. To je znak, da je operacijski sistem prestregel znak C-s in ga interpretiral kot znak za prekinitev toka podatkov, namesto da bi ga posredoval programu Emacs. Ekran ,,odtajate`` s pritiskom na C-q. Potem si oglejte razdelek ,,Spontaneous Entry to Incremental Search`` v priroèniku za nasvet, kako se spopasti s to nev¹eènostjo. Èe sredi inkrementalnega iskanja pritisnete <Delete>, boste opazili, da to pobri¹e zadnji znak v iskanem nizu, kazalèek pa se premakne nazaj na mesto v besedilu, kjer je na¹el kraj¹i niz. Na primer, predpostavimo, da ste do zdaj natipkali ,,ka`` in je kazalèek na mestu, kjer se prviè pojavi ,,ka``. Èe zdaj pritisnete <Delete>, boste s tem v pogovornem vmesniku izbrisali ,a`, hkrati pa se bo kazalèek postavil na mesto, kjer je prviè na¹el ,k`, preden ste natipkali ¹e ,a`. Èe sredi iskanja vtipkate katerikoli kontrolni znaki ali metaznak (razen tistih, ki imajo poseben pomen pri iskanju, to sta C-s in C-r), se iskanje prekine. C-s zaène iskati na mestu v datoteki, kjer trenutno stoji kazalèek, in i¹èe do konca datoteke. Èe bi radi iskali proti zaèetku datoteke, namesto C-s vtipkamo C-r. Vse, kar smo povedali o ukazu C-s, velja tudi za C-r, le smer iskanja je obrnjena. * VEÈ OKEN NA ZASLONU --------------------- Ena simpatiènih lastnosti Emacsa je, da zna hkrati prikazati veè oken na ekranu, tudi èe ne delamo v grafiènem naèinu. >> Premaknite kazalèek v to vrstico in vtipkajte C-u 0 C-l. >> Zdaj vtipkajte C-x 2, da razdelite zaslon na dve okni. V obeh oknih imate odprt ta priroènik. Kazalèek je ostal v zgornjem oknu. >> Pritisnite C-M-v za listanje v spodnjem oknu. (Èe nimate tipke Meta, tipkajte ESC C-v). >> Vtipkajte C-x o (o kot ,,other``, drugi), da preselite kazalèek v spodnje okno. >> S C-v in M-v se v spodnjem oknu premikate po vsebini datoteke. Zgornje okno ¹e vedno ka¾e ta navodila. >> Ponovni C-x o vas vrne v zgornje okno. Kazalèek se je vrnil na mesto, kjer je bil, preden smo skoèili v spodnje okno. Z ukazom C-x o lahko preklapljamo med okni. Vsako okno si zapomni, kje v oknu je ostal kazalèek, samo trenutno aktivno okno pa kazalèek tudi v resnici prika¾e. Vsi obièajni ukazi za urejanje, ki smo se jih nauèili, veljajo za aktivno okno. Ukaz C-M-v je zelo uporaben, kadar urejamo besedilo v enem oknu, drugega pa uporabljamo samo za pomoè. Kazalèek ostaja ves èas v oknu, v katerem urejamo, po vsebini spodnjega okna pa se vseeno lahko premikamo, ne da bi morali venomer skakati iz enega okna v drugega. C-M-v je primer znaka CONTROL-META. Èe imate v resnici tipko Meta (na PC navadno levi Alt), lahko vtipkate C-M-v tako, da dr¾ite pritisnjeni tako CONTROL kot META, medtem ko vtipkate v. Ni pomembno, katero od tipk, CONTROL ali META, pritisnete prvo, saj obe delujeta ¹ele, ko pritisnete znak, ki sledi (v zgornjem primeru ,v`). Nasprotno pa je vrstni red pritiskanja pomemben, èe nimate tipke META in namesto nje uporabljate ESC. V tem primeru morate najprej pritisniti ESC, potem pa Control-v. Obratna kombinacija, Control-ESC v ne deluje. To je zato, ker je ESC znak sam po sebi, ne pa modifikator, kot sta CONTROL in META. >> V zgornjem oknu vtipkajte C-x 1, da se znebite spodnjega okna. (Èe bi vtipkali C-x 1 v spodnjem oknu, bi se znebili zgornjega. Razmi¹ljajte o tem ukazu kot ,,Obdr¾i samo eno okno, in sicer tisto, v katerem sem zdaj.``) Seveda ni nujno, da obe okni ka¾eta isto delovno podroèje. Èe v enem oknu izvedete C-x C-f in poi¹èete novo datoteko, se vsebina drugega okna ne spremeni. V vsakem oknu lahko neodvisno obdelujete drugo datoteko. Pa ¹e ena pot, kako v dveh oknih prika¾ete dve razlièni datoteki: >> Vtipkajte C-x 4 C-f, in na pozivnik vtipkajte ime ene va¹ih datotek. Konèajte z <Return>. Odpre se ¹e eno okno in izbrana datoteka se pojavi v drugem oknu. Tudi kazalèek se preseli v drugo okno. >> Vtipkajte C-x o, da se vrnete nazaj v zgornje okno, in C-x 1, da zaprete spodnje okno. * REKURZIVNI NIVOJI UREJANJA ---------------------------- Vèasih boste pri¹li v nekaj, èemur se pravi ,,rekurzivni nivo urejanja``. To se vidi po tem, da v statusni vrstici oglati oklepaji oklepajo ime glavnega naèina. V osnovnem naèinu bi, na primer, videli [(Fundamental)] namesto (Fundamental). Iz rekurzivnega nivoja urejanja se re¹ite, èe vtipkate ESC ESC ESC. To zaporedje je vsenamenski ukaz ,,pojdi ven``. Uporabite ga lahko tudi za ukinjanje odveènih oken, ali vrnitev iz pogovornega vmesnika. >> Pritisnite M-x, da odprete pogovorni vmesnik, zatem pa vtipkajte ESC ESC ESC, da pridete ven iz njega. Z ukazom C-g ne morete iz rekurzivnega nivoja urejanja, ker C-g preklièe ukaze ali argumente ZNOTRAJ rekurzivnega nivoja. * DODATNA POMOÈ --------------- V tem uvodu smo posku¹ali zbrati dovolj informacij, da lahko zaènete Emacs uporabljati. Emacs ponuja toliko, da bi bilo nemogoèe vse to zbrati tukaj. Verjetno pa bi se vseeno radi nauèili kaj o ¹tevilnih koristnih mo¾nostih, ki jih ¹e ne poznate. Emacs ima ¾e vgrajene veliko dokumentacije, do katere lahko pridete s pritiskom na CTRL-h (h kot ,,help``, pomoè). Za pomoè pritisnete C-h, potem pa vtipkate znak, ki pove, kak¹no pomoè ¾elite. Èe ste poplnoma izgubljeni, vtipkajte C-h ? in Emacs vam bo povedal, kak¹na pomoè je sploh na voljo. Èe ste vtipkali C-h, pa ste si premislili, lahko ukaz preklièete s C-g. (Ponekod se znak C-h preslika v kaj drugega. To ni dobro, in v takem primeru se prito¾ite sistemskemu vzdr¾evalcu. Medtem pa, èe C-h ne prika¾e sporoèila o pomoèi na dnu zaslona, namesto tega poskusite pritisniti tipko F1 ali pa vtipkajte M-x help <Return>.) Najosnovnej¹i tip pomoèi prika¾e C-h c. Pritisnite C-h, tipko c, zatem pa ukazni znak ali zaporedje ukaznih znakov, in Emacs bo izpisal kratek opis ukaza. >> Vtipkajte C-h c Control-p. Izpi¹e se nekaj takega kot C-p runs the command previous-line Ukaz je izpisal ime funkcije, ki izvede ukaz. Imena funkcij uporabljamo, kadar pi¹emo prilagoditve in raz¹iritve Emacsa. Ker pa so navadno imena funkcij izbrana tako, da kaj povedo o tem, kaj funkcija poène, bo verjetno to tudi dovolj za kratko osve¾itev, èe ste se z ukazom ¾e kdaj sreèali. Ukazu C-h lahko sledi tudi zaporedje znakov, kot na primer C-x C-s, ali, èe nimate tipke META, <Esc>v. Za veè informacij o ukazu vtipkajte C-h k namesto C-h c. >> Vtipkajte C-h k Control-p. To odpre novo okno in v njem prika¾e dokumentacijo o funkciji, obenem z njenim imenom. Ko ste opravili, vtipkajte C-x 1, da se znebite okna z pomoèjo. Tega seveda ni potrebno napraviti takoj, ampak lahko urejate, medtem ko imate odprto okno s pomoèjo, in ga zaprete, ko ste konèali. Sledi ¹e nekaj uporabnih mo¾nosti, ki jih ponuja pomoè: C-h f Opi¹i funkcijo. Kot argument morate podati ime funkcije. >> Poskusite C-h f previous-line<Return>. To izpi¹e vse podatke, ki jih ima Emacs o funkciji, ki izvede ukaz C-p. C-h a Apropos. Vtipkajte kljuèno besedo in Emacs bo izpisal vse ukaze, ki vsebujejo to kljuèno besedo. Vse te ukaze lahko priklièete z Meta-x. Pri nekaterih ukazih bo Apropos izpisal tudi eno ali dvoznakovno zaporedje, s katerim dose¾ete isti uèinek. >> Vtipkajte C-h a file<Return>. To odpre novo okno, v katerem so vsa dolga imena ukazov, ki vsebujejo ,,file`` v imenu. Izvedete jih lahko z M-x. Pri nekaterih se izpi¹e tudi kratek ukaz, npr. C-x C-f ali C-x C-w pri ukazih find-file in write-file. >> Pritisnite C-M-v, da se sprehajate po oknu s pomoèjo. Poskusite nekajkrat. >> Vtipkajte C-x 1, da zaprete okno s pomoèjo. * ZAKLJUÈEK ----------- Zapomnite si, da Emacs zapustite z ukazom C-x C-c. Èe bi radi samo zaèasno skoèili v ukazno lupino in se kasneje vrnili v Emacs, pa storite to z ukazom C-z. Ta uèbenik je napisan z namenom, da bi bil razumljiv vsem novincem v Emacsu. Èe se vam kaj ne zdi jasno napisano, ne valite krivde nase - prito¾ite se! RAZMNO®EVANJE IN RAZ©IRJANJE ---------------------------- Angle¹ki izvirnik tega uvoda v Emacs je naslednik dolge vrste tovrstnih besedil, zaèen¹i s tistim, ki ga je Stuart Cracraft napisal za izvorni Emacs. V sloven¹èino ga je prevedel Primo¾ Peterlin. To besedilo, kot sam GNU Emacs, je avtorsko delo, in njegovo razmno¾evanje in raz¹irjanje je dovoljeno pod naslednjimi pogoji: Copyright (c) 1985, 1996, 1997 Free Software Foundation Dovoljeno je izdelovati in raz¹irjati neokrnjene kopije tega spisa v kakr¹nikoli obliki pod pogojem, da je ohranjena navedba o avtorstvu in to dovoljenje, ter da distributer dovoljuje prejemniku nadaljnje raz¹irjanje pod pogoji, navedenimi v tem dovoljenju. Pod pogoji iz prej¹njega odstavka je dovoljeno raz¹irjati spremenjene verzije tega spisa ali njegovih delov, èe je jasno oznaèeno, kdo je nazadnje vnesel spremembe. Pogoji za razmno¾evanje in raz¹irjanje samega Emacsa so malo drugaèni, a v istem duhu. Prosimo, preberite datoteko COPYING in potem dajte kopijo programa GNU Emacs svojim prijateljem. Pomagajte zatreti obstrukcionizem (,,lastni¹tvo``) v programju tako, da uporabljate, pi¹ete in delite prosto programje! ;;; Local Variables: ;;; coding: iso-latin-2 ;;; End: Copyright (c) 1985 Free Software Foundation, Inc; Vea al final las condiciones. Usted está viendo el tutorial de Emacs. Los comandos de Emacs generalmente ivolucran a la tecla CONTROL (algunas veces llamada CTRL O CTL) o la tecla meta algunas veces llamada (EDIT o ALT). En lugar de escribir esto completamente en cada ocasión, usaremos las siguientes abreviaciones. C-<chr> significa mantener presionada la tecla CONTROL mientras digita el caracter <chr>. Por lo tanto C-f será: Mantenga presionada la tecla CONTROL y digite f. M-<chr> significa mantega presionada la tecla META o EDIT o ALT mientras digita <chr>. Si no hay teclas META, EDIT o ALT, en su lugar presione y libere la tecla <esc> y luego digite <CHR>. Escribimos <ESC> para la tecla ESC. Nota importante: para finalizar la sesión de Emacs presione C-x C-c. (dos caracteres.) los caracteres ">>" al margen izquierdo indican instrucciones para que usted trate de usar un comando. Por ejemplo: <<Blank lines inserted here by startup of help-with-tutorial>> >> Ahora digite C-v (ver la proxima pantalla) para desplazarse a la siguiente pantalla (hágalo manteniendo la tecla control oprimida mientras digita v). Desde ahora usted deberia hacer esto cada vez que termine de leer la pantalla Note que se sobrelapan dos líneas cuando usted se mueve de pantalla en pantalla; esto proveé una continuidad para que pueda seguir leyendo el texto. La primera cosa que necesita saber es como moverse de un lugar a otro en el texto. Usted ya sabe como adelantar una pantalla con C-v. Para mover atras una pantalla oprima M-v (mantega oprimida la tecla META y digite v, o presione <ESC>v si no tiene las teclas META, EDIT o ALT). >> Intente oprimir M-v y luego C-v, varias veces. * RESUMEN --------- Los siguentes comandos son útiles para ver pantallas completas: C-v Avanzar una pantalla completa M-v Retroceder una pantalla completa C-l Limpiar la pantalla y mostrar todo el texto de nuevo, moviendo el texto alrededor del cursor al centro de la pantalla (Esto es control-L, no control-1.) >> Encuentre el cursor,y note cual texto está cerca a este. Luego oprima C-l. Encuentre el cursor otra vez y note que el mismo texto está cerca al cursor ahora. * MOVIMIENTO BÁSICO DE CURSOR ----------------------------- Moverse de una pantalla completa a otra es útil, pero cómo moverse a un lugar específico dentro del texto en la pantalla? Hay varias formas para que pueda hacerlo. La forma más básica es usar los comandos C-p, C-b, C-f, y C-n. Cada uno de estos comandos mueve el cursor una fila o columna en una dirección particular en la pantalla. Aquí hay una tabla mostrando estos cuatro comandos y las direcciones en que ellos mueven Línea Anterior, C-P : : Atrás, C-b.... Posición actual del cursor .... Adelante, C-f : : Línea siguiente, C-n >> Mueva el cursor a la línea en la mitad del diagrama usando C-n o C-p. Luego presione C-l para ver el diagrama completo centrado en la pantalla. Usted probablemente encontrará fácil recordarlos mediante las letras P de Previous (anterior), N de Next (siguiente), B de Backward (atrás) y F de Forward (adelante). Estos son los comandos básicos de posicionamiento del cursor y estará usándolos TODO el tiempo, serán de gran beneficio si los aprende a usar ahora. >> Presione unas veces C-n para traer el cursor a esta línea. >> Muévase en la línea con C-f y hacia arriba con C-p. Observe lo que hace C-p cuando el cursor está en la mitad de la línea. Cada línea de texto termina con un caracter de nueva línea, esto sirve para separarla de la siguiente línea. La última línea en su archivo debe tener una nueva línea al final (pero Emacs no requiere que esta lo tenga). >> Intente usar C-b al comienzo de una línea. Debería moverse al final de la línea previa. Esto es porque retrocede antes del caracter de nueva línea. C-f puede moverse por una nueva línea justo como C-b. >> Presione algunas C-b más para que entienda donde se encuentra el cursor. Luego presione C-f para retornar al final de la línea. Al final presione una vez mas C-f para moverse a la siguiente línea. Cuando pase el tope o el final de la pantalla, el texto más alla del borde de la pantalla se mostrará. Esto es llamado "desplazamiento" Esto le permite a Emacs mover el cursor al lugar especificado en el texto sin moverlo fuera de la pantalla. >> Intente mover el cursor fuera del borde de la pantalla con C-n y observe qué pasa. Si moverse por caracteres es muy lento, se puede mover por palabras. M-f (META-F) mueve adelante una palabra y M-b mueva atrás una palabra. >> Oprima unas veces M-f y M-b Cuando está en la mitad de una palabra, M-f mueve al final de la palabra. Cuando está en un espacio entre dos palabras, M-f mueve al final de la siguiente palabra. M-b trabaja de la misma forma en la dirección opuesta. >> Oprima unas veces M-f y M-b, intercale con C-f y C-b de tal forma que observe la acción de M-f y M-b desde varios sitios dentro y entre palabras. Note el paralelo entre C-f y C-b de un lado y M-f y M-b del otro. Muy frecuentemente los caracteres Meta son usados para operaciones relacionadas, con las unidaes definidas por el lenguaje (palabras, oraciones y parrafos), mientras los caracteres Control operan sobre unidades que son independientes de lo que usted está editando (caracteres, líneas, etc). Este paralelo se aplica entre líneas y oraciones: C-a y C-e para moverse al comienzo o al final de la línea; y M-a y M-e para mover al comienzo o al final de una oración. >> Intente unas veces C-a, y a continuación C-e. >> Intente unos M-a, y otros M-e. Mire cómo la repeticion de C-a no hace nada, pero la repeticion de M-a sigue moviendo una oración adelante, aunque no son muy análogas, cada una parece natural. La localización del cursor en el texto es también llamada "punto", en otras palabras el cursor muestra sobre la pantalla donde esta el punto localizado dentro del texto. Aquí hay un resumen de operaciones simples del movimiento del cursor, incluyendo los comandos de movimiento en oracion y palabra: C-f Moverse adelante un caracter C-d Moverse atrás un caracter M-f Moverse adelante una palabra M-b Moverse atrás una palabra C-n Moverse a la línea siguiente C-p Moverse a la línea anterior C-a Moverse al comienzo de la línea C-e Moverse al final de la línea M-a Moverse al comienzo de la oración M-e Moverse al final de la oración >> Pruebe todos estos comandos unas veces para practicar. Estos comandos son los usados más frecuentemente. Otros dos comandos de movimiento del cursor importantes son M-< (Meta Menor que), el cual se mueve al comienzo del texto entero, y M->( Meta Mayor que), el cual se mueve al final del texto entero. En la mayoría de terminales, el "<" está sobre la coma, por lo tanto usted puede usar la tecla shift para generarlo. En estas terminales usted podrá usar la tecla shift también al teclear M-<; sin la tecla shift, usted estaría escribiendo M-coma. >> Ahora pruebe M-<, para moverse al comienzo del tutorial. A continuación use C-v repetidamente para regresar aquí. >> Ahora pruebe M->, para moverse el final del tutorial. Después use M-v repetidamente para regresar aquí. También puede mover el cursor con las teclas de la flecha si su terminal tiene teclas de flecha. Recomendamos aprender C-b, C-f, C-n y C-p por tres razones. Primero, ellos funcionan en todo tipo de terminales. Segundo, una vez usted gane práctica usando Emacs, usted encontrará que teclear estos caracteres Control es más rápido que usar teclas de flecha ( porque no tendrá que retirar sus manos de la posición para teclear). Tercero, una vez tenga el hábito de usar estos comandos Control, también puede aprender fácilmente a usar otros comandos avanzados de movimiento de cursor. La mayoría de comandos de Emacs aceptan un argumento númerico; para la mayoría de comandos esto sirve como un factor de repetición. La manera que a un comando usted da un factor de repetición es tecleando C-u y luego los dígitos antes de introducir los comandos. Si usted tiene una tecla META ( o EDIT o ALT), hay una manera alternativa para ingresar un argumento númerico: teclear los dígitos mientras presiona la tecla META. Recomendamos aprender el método C-u porque este funciona en cualquier terminal. El argumento númerico es también llamado un "argumento prefijo", porque usted teclea el argumento antes del comando al que se aplica. Por ejemplo, C-u 8 C-f mueve hacia adelante ocho caracteres. >> Pruebe usar C-n o C-p con un argumento númerico, para mover el cursor a una línea cerca a esta con solo un comando. La mayoría de comandos usan argumentos numéricos como un factor de repetición, pero algunos comandos lo usan de otra forma. Varios comandos (pero ninguno de los que ha aprendido hasta ahora) usan esto como una marca -- la presencia de un argumento prefijo, sin tener en cuenta su valor, hace que el comando actúe de forma diferente. C-v y M-v son otro tipo de excepción. Cuando se les da un argumento, ellos desplazan la pantalla arriba o abajo esa cantidad de líneas, en vez de una pantalla completa. Por ejemplo, C-u 8 C-v desplaza la pantalla 8 líneas. >> Pruebe tecleando C-u 8 C-v ahora. Este debió haber desplazado la pantalla hacia arriba 8 líneas. Si usted quisiera desplazarla hacia abajo de nuevo, usted puede dar un argumento a M-v. Si usted esta usando X Window, debe haber una área rectangular larga llamada una barra de desplazamiento al lado izquierdo de la ventana de Emacs. Usted puede desplazar el texto al oprimir el boton del mouse en la barra de desplazamiento. >> Pruebe presionando el botón del medio en la parte superior del area resaltada en la barra de desplazamiento. Este debe desplazar el texto a una posición determinada por cuán alto o bajo oprima el botón. >> Intente mover el mouse arriba y abajo, mientras mantiene el botón el medio presionado. Usted verá que el texto se desplaza arriba y abajo a medida que mueve el mouse. * CUANDO EMACS ESTÁ BLOQUEADO ----------------------------- Si Emacs deja de responder a sus comandos, usted puede detenerlo con seguridad al teclear C-g. Puede usar C-g para detener un comando que está tomando mucho tiempo para ejecutarse. También puede usar C-g para descartar un argumento númerico o el comienzo de un comando que usted no quiere finalizar. >> Escriba C-u 100 para hacer un argumento númerico de 100, entonces pruebe C-g. Ahora pruebe C-f. Esto deberá mover sólo un caracter, ya que usted canceló el argumento con C-g. Si usted ha digitado <ESC> por error, usted puede desecharlo con un C-g. * COMANDOS DESACTIVADOS ----------------------- Algunos comandos de Emacs son "desactivados" de manera que los usuarios principiantes no puedan usarlos por accidente. Si usted prueba uno de los comandos desactivados, Emacs muestra un mensaje informando cuál comando era, y preguntándole si usted quiere continuar y ejecutar el comando. Si usted realmente quiere intentar el comando, oprima espacio como repuesta a la pregunta. Normalmente, si usted no quiere ejecutar el comando desactivado, conteste la pregunta con "n". >> Escriba C-x C-1 (que es un comando desactivado), a continuación escriba n para responder la pregunta. * VENTANAS ---------- Emacs puede tener varias ventanas, cada una mostrando su propio texto. Explicaremos después como usar múltiples ventanas. Ahora queremos explicar cómo deshacerse de ventanas adicionales y volver a la edición básica en una ventana. Es sencillo: C-x 1 Una ventana (i.e., elimina todas las otras ventanas). Esto es Control x seguido por el digito 1. C-x 1 expande la ventana que contiene el cursor, para ocupar toda la pantalla. Esto borra todas las otras ventanas. >> Mueva el cursor a esta línea y escriba C-u 0 C-l. >> Escriba Control-h k Control-f. Mire como esta ventana se encoge, mientras una nueva aparece y muestra documentacion sobre el comando Control-f. >> Escriba C-x 1 y vea la ventana de listado de documentación desaparecer. Este comando es diferente a los otros comandos que usted ha aprendido en que este consiste de dos caracteres. Este comienza con el caracter Control-x. Hay toda una serie de comandos que comienzan con Control-x; muchos de ellos tienen que ver con ventanas, archivos, buffers y cosas relacionadas. Estos comandos son de una longitud de dos, tres o cuatro caracteres. * INSERTANDO Y BORRANDO ----------------------- Si usted quiere insertar un texto sólo escribalo. Los caracters que usted puede ver, tales como A, 7, *, etc. Son tomados por Emacs como texto e insertados inmediatamente. Oprima <Return> (la tecla Enter) para insertar un caracter de nueva línea. Usted puede borrar el último caracter que escribió oprimiendo <Delete>. <Delete> es una tecla, que puede estar marcada como "Del". En algunos casos la tecla "Backspace" sirve como <Delete>, ¡pero no siempre! Generalmente <Delete> borra el caracter inmediatamente anterior a la posición actual del cursor. >> Haga esto ahora -- Teclee unos pocos caracteres, y bórrelos con la tecla <Delete>. No se preocupe si este archivo cambia, no alterará el tutorial principal. Esta es su copia personal. Cuando una línea de texto se hace muy grande para una sola línea en la pantalla, la línea de texto es "continuada" en una segunda línea. Un backslash ("\") en el margen derecho indica que la línea ha sido continuada. >> Inserte texto hasta que llegue al margen derecho, y siga insertando. Verá a continuación aparecer una línea. >> Use <Delete> para borrar el texto hasta que la línea de nuevo quepa en la pantalla. La línea de continuación se pierde. Puede borrar un caracter de Nueva línea justo como cualquier otro caracter. Al borrar un caracter de Nueva línea entre dos líneas las combina en una sola. Si el resultado de la combinación de líneas es demasiado largo para caber en el ancho de la pantalla, será mostrada una línea de continuación. >> Mueva el cursor al comienzo de una línea y oprima <Delete>. Esto unirá esta línea con la anterior. >> Oprima <Return> para reinsertar la nueva línea que borró. Recuerde que a la mayoría de los comandos de Emacs se les puede dar un factor de repetición, esto incluye caracteres de texto. Repetir un caracter de texto lo inserta varias veces. >> Ahora trate esto -- teclee C-u 8 * para insertar ********. Usted ha aprendido la manera más básica de teclear algo en Emacs y corregir errores. Puede borrar por palabras o por líneas. Este es un resumen de las operaciones de borrado: <Delete> borra el caracter justo antes que el cursor C-d borra el siguiente caracter después del cursor M-<Delete> Elimina la palabra inmediatamente antes del cursor M-d Elimina la siguiente palabra antes del cursor C-k Elimina desde el cursor hasta el fin de la línea M-k Elimina hasta el final de la oración actual. Note que <Delete> y C-d contra M-<Delete> y M-d extienden el paralelo iniciado por C-f y M-f (bien, <Delete> no es realmente una tecla de control, pero no nos preocuparemos ahora por eso). C-k y M-k son como C-e y M-e, en ciertas forma, en que las líneas son oraciones opuestas. También puede eliminar cualquier parte del buffer con un método uniforme. Muevase a un extremo de esa parte, y digite C-＠ o C-SPC (cualquiera de los dos). Muévase al extremo de esa parte y teclee C-w. Eso elimina todo el texto entre las dos posiciones. >> Mueva el cursor a la letra T al inicio del párrafo anterior. >> Teclee C-SPC. Emacs debe mostrar el mensaje "Mark set" en la parte de abajo de la pantalla. >> Mueva el cursor a la x en "extremo", en la segunda línea del parrafo. >> Teclee C-w. Esto eliminará el texto que comienza desde la T, y termina justo antes de la x. Cuando usted borra más de un caracter a la vez, Emacs salva el texto borrado de manera que usted lo puede recuperar. Recuperar el texto se llamará "yanking". Usted puede recuperar el texto eliminado en el lugar donde fue eliminado, o en otro lugar en el texto. Usted puede recuperar el texto varias veces para hacer múltiples copias de este. El comando para recuperar es C-y. Note la diferencia entre "Eliminar" y "Borrar" las cosas que "elimina" pueden ser recuperadas y las que "borra" no. Generalmente, los comandos que pueden remover mucho texto lo salvan, mientras los comandos que borran sólo un caracter, o líneas y espacios, no salvan el texto borrado. >> Mueva el cursor al comienzo de una línea que no esté desocupada. Luego digite C-k para eliminar el texto de esa línea. >> Oprima C-k por segunda vez. Usted verá que elimina la nueva línea que sigue a esa. Note que al oprimir C-k una sola vez elimina el contenido de la línea , y un segundo C-k elimina la línea misma, y hace que todas las otras líneas se muevan hacia arriba. C-k trata un argumento numérico especialmente: Elimina ese número de líneas y sus contenidos. Esto no es una simple repetición. C-u 2 C-k elimina dos líneas y sus nuevas líneas, tecleando C-k dos veces no hace esto. Para recuperar el último texto eliminado y ponerlo donde el cursor actualmente está, oprima C-y >>Inténtelo; oprima C-y para recuperar el texto. Piense en C-y como si estuviera recuperando algo que alguien le quitó. Note que si usted hace varias C-k seguidas, todo lo que ha sido eliminado del texto se salva junto, de manera que un C-y recuperará todas las líneas. >>Haga esto ahora, oprima C-k varias veces. Ahora para recuperar ese texto eliminado: >> Teclee C-y. Entonces baje el cursor unas pocas líneas y oprima C-y de nuevo. Ahora sabe como copiar un texto. Qué hacer si usted tiene algún texto que quiere recuperar, pero elimina otro antes de recuperarlo? C-y recuperaría la eliminación más reciente, pero el texto previo no está perdido. Puede regresar a éste usando el comando M-y. Después de haber tecleado C-y para conseguir la eliminación más reciente, escribiendo M-y reemplaza el texto recuperado con la eliminación previa. Tecleando M-y una y otra vez traerá las eliminaciones anteriores. Cuando usted ha encontrado el texto que buscaba, usted no tiene que hacer nada para conservarlo.Sólo siga con su edición, dejando el texto recuperado donde está. Si usted digita M-y suficientes veces, usted regresa al punto inicial (la eliminación más reciente) >> Elimine una línea muévase, elimine otra línea. Luego oprima C-y para recuperar la segunda línea eliminada. Entonces oprima M-y, y será reemplazada por la primera línea eliminada. Oprima más veces M-y y vea lo que sucede. Siga haciéndolo hasta que la segunda línea eliminada regrese, y entonces unas pocas más. Si usted quiere, puede tratar de darle a M-y argumentos positivos y negativos. * DESHACER ---------- Si hace un cambio al texto, y luego decide que fue un error, puede deshacer el cambio con el comando deshacer C-x u. Normalmente, C-x u deshace los cambios hechos por un comando; si repite varias veces seguidas C-x u, cada repetición deshará un comando adicional. Pero hay dos excepciones: comandos que no cambian el texto no cuentan (esto incluye los comandos de movimiento del cursor y el comando de desplazamiento), y los caracteres de autoinserción son usualmente manejados en grupos de hasta 20 (estos es para reducir el numero de C-x u que tiene que realizar para deshacer una inserción en el texto). >> Elimine esta línea con C-k, después C-x u debería reaparecerla. C-_ es un comando alterno para deshacer, este trabaja igual que C-x u, pero es más facil de usar varias veces seguidas. La desventaja de C-_ es que en algunos teclados no es obvio como se genera. Por esto proveemos C-x u también. En algunas terminales, usted puede oprimir C-_ al digitar / mientras oprime CONTROL. Un argumento numérico para C-_ o C-x u actúa como un factor de repetición. * ARCHIVOS ---------- Para hacer permanente el texto que edite, lo debe colocar en un archivo. De otra manera, este se se perderá cuando cierre Emacs. Para poder poner su texto en un archivo, usted debe "encontrar" el archivo antes de ingresar el texto (esto también es llamado "visitar" el archivo.) Encontrar un archivo significa que usted puede observar su contenido dentro de Emacs. Esto de cierta forma, es como si usted estuviera editando el archivo. Aunque los cambios que usted haga usando Emacs no serán permanentes hasta que "salve" el archivo. Esto es para no dejar un archivo a medio cambiar en el sistema cuando usted no quiere. Incluso cuando usted salve, Emacs dejará el archivo original bajo un nombre cambiado en caso de que luego usted decida que sus cambios fueron un error. Si mira cerca del final de la pantalla podrá ver una línea que comienza y termina con guiones, y comienza con "--:-- TUTORIAL" o algo así. Esta parte de la pantalla normalmente muestra el nombre del archivo que está visitando. En este momento usted está visitando un archivo llamado "TUTORIAL" que es su borrador personal del tutorial de Emacs. Cuando encuentre un archivo con Emacs, el nombre del archivo aparecerá en ese mismo sitio. Una cosa especial acerca del comando para encontrar un archivo, es que usted tendrá que decir cual archivo desea. Decimos que el comando "lee un argumento desde la terminal" (en este caso, el argumento es el nombre del archivo). Despues de generar el comando: C-x C-f Encontrar un archivo Emacs le pide que digite el nombre del archivo. El nombre de archivo que digite aparecerá en la línea final de la pantalla. A la línea final de la pantalla se le denomina minibuffer cuando es usada para este tipo de entradas. Puede usar comandos de edición ordinarios de Emacs para editar el nombre del archivo. Cuando está ingresando el nombre del archivo (o cualquier otra información al minibuffer) usted puede cancelar el comando con C-g. >> Oprima C-x C-f, luego oprima C-g. Esto cancela el minibuffer y también cancela el comando C-x C-f que estaba usando el minibuffer. Así que no encontrará archivo alguno. Cuando usted haya finalizado de ingresar el nombre del archivo, oprima <Return> para terminarlo. Entonces el comando C-x C-f trabaja y encuentra el archivo que usted escogió. El minibuffer desaparece cuando el comando C-x C-f termina. Después aparece el contenido del archivo en la pantalla y usted puede editarlo. Cuando quiera hacer cambios permanentes, teclee el comando C-x C-s Salvar el archivo Este copia el texto de Emacs al archivo. La primera vez que usted haga esto, Emacs renombrará el archivo original con un nuevo nombre para que este no se pierda. El nuevo nombre se obtendrá adicionándo "~" al final del nombre del archivo original. Cuando la operación de salvar haya terminado, Emacs mostrará el nombre del archivo escrito. Usted debería salvar frecuentemente, para que no pierda mucho trabajo si el sistema deja de funcionar. >> Presione C-x C-s, salvando la copia del tutorial. Esto debería imprimir "Wrote...TUTORIAL" al final de la pantalla. NOTA: En algunos sistemas, oprimir C-x C-s dejará inmóvil la pantalla y usted no podrá ver más respuesta de Emacs. Esto indica que una "característica" del sistema operativo llamada ''control de flujo'' está interceptando el comando C-s y no permitiéndole llegar a Emacs. Para descongelar la pantalla, presione C-q. Entonces consulte la sección "entrada espontánea para búsqueda incremental'' en el manual de Emacs para encontrar información de cómo tratar con esta "característica". Usted puede encontrar un archivo existente para verlo o editarlo, también puede hacerlo con un archivo que no existe. Esta es la forma de crear un archivo en Emacs: encuentre el archivo, comenzará vacio, luego comience a introducir el texto al archivo. Cuando invoque "salvar" el archivo, Emacs creará realmente el archivo con el texto que introdujo. Desde ahí, usted puede considerarse estar editando un archivo existente. * BUFFERS --------- Si visita un segundo archivo con C-x C-f, el primer archivo permanece en Emacs. Usted puede volver al primer encontrándolo de nuevo con C-x C-f. De esta forma usted puede mantener un gran número de archivos en Emacs. >> Cree un archivo llamado "foo" presionando C-x C-f foo <Return> luego inserte algún texto, edítelo, y salve "foo" presionando C-x C-s. Finalmente presione C-x C-f TUTORIAL <Return> para regresar al tutorial. Emacs almacena cada archivo de texto dentro de un objeto llamado "buffer". Al encontrar un archivo se crea un nuevo buffer dentro de Emacs. Para mirar la lista de los buffers que existen actualmente en su sesión de Emacs, presione: C-x C-b Lista de Buffers >> Intente ahora C-x C-b. Mire como cada buffer tiene un nombre, y ademas puede tener un nombre de archivo para el archivo que contiene. Algunos Buffers no corresponden a archivos; por ejemplo, el buffer llamado "*Buffer List*" no tiene ningún archivo. Este es el buffer que tiene la lista de buffers que fue creado por C-x C-b. CUALQUIER archivo de texto que vea en una ventana de Emacs, es siempre parte de algún Buffer. >> Presione C-x 1 para deshacerse de la lista de buffers. Si usted hace cambios al texto de un archivo, y luego encuentra otro archivo, esto no salva el primer archivo. Estos cambios permanecerán dentro de Emacs en el buffer del archivo. La creación o edición del segundo buffer de archivo no afecta al primero. Esto es muy útil pero significa que necesita una forma conveniente para salvar el archivo del primer buffer. Sería una molestia tener que volver a este con C-x C-f para salvarlo con C-x C-s así que tenemos C-x s Guardar algunos buffers C-x s le pregunta sobre cada buffer que contenga cambios que usted no ha salvado. Le pregunta por cada buffer si salvarlo o no. >> Inserte una línea de texto, y teclee C-x s. Esto debería preguntarle si desea salvar el buffer llamado TUTORIAL. Conteste si a la pregunta presionando "y". * EXTENDIENDO EL CONJUNTO DE COMANDOS ------------------------------------- Hay muchísimos más comandos de Emacs que podrían ser posiblemente puestos en todos los caracteres control y meta. Emacs puede lograrlo usando el comando X (eXtendido). Este viene de dos formas: C-x Caracter eXtendido seguido por un caracter. M-x Comando eXtendido por nombre. Seguido por un nombre largo. Estos comandos son generalmente útiles pero usados menos que los comandos que usted hasta ahora ha aprendido. Hasta ahora ha visto dos de estos: los comandos de archivo C-x C-f para encontrar y C-x C-s para salvar. Otro ejemplo es el comando para terminar la sesión de Emacs -- este es el comando C-x C-c ( no se preocupe por perder los cambios que usted haya hecho; C-x C-c ofrece salvar cada archivo alterado antes de que este elimine a Emacs.) C-z es el comando para salir de Emacs *temporalmente*-- para que usted pueda regresar a la misma sesión de Emacs después. En sistemas que lo permiten C-z "suspende" Emacs; esto es, se retorna al shell pero no se destruye Emacs. En los shells más comunes, usted puede reanudar Emacs con el comando `fg' o con `%emacs'. En sistemas que no se implemente el suspendido, C-z crea un subshell que corre bajo Emacs para darle la opción de correr otros programas y regresar a Emacs después; esto en realidad no "sale" de Emacs. En este caso, el comando shell `exit' es la vía usual para regresar a Emacs desde el subshell. El momento para usar C-x C-c es cuando usted está listo para salir. Es además el paso correcto para salir de Emacs llamado bajo programas de manejo de correo y otra variedad de utilidades, puesto que ellos no saben cómo lidiar con la suspensión de Emacs. En circunstancias normales, si usted no va a salir, es mejor suspender Emacs con C-z en lugar de salir de este. Existen varios comandos C-x. Aqui hay una lista de algunos que usted ha aprendido: C-x C-f Encontrar archivo. C-x C-s Salvar archivo. C-x C-b Lista de buffers. C-x C-c Salir de Emacs. C-x 1 Borrar todo menos una ventana. C-x u Deshacer. Los comandos llamados eXtendidos son comandos usados con menos frecuencia o comandos que son usados únicamente en ciertos modos. Un ejemplo es el comando replace-string, el cual globalmente reemplaza una cadena con otra. Cuando usted teclea M-x, Emacs le pregunta al final de la pantalla con M-x y usted debe escribir el nombre del comando; en este caso "replace-string". Solo escriba "repl s<TAB>" y Emacs completará el nombre. Finalice el nombre del comando con <Return>. El comando replace-string requiere dos argumentos -- la cadena a reemplazar, y la cadena para reemplazarla. Usted debe terminar cada argumento con <Return>. >> Mueva el cursor hacia la línea en blanco dos líneas debajo de esta. A continuación escriba M-x repl s<Return>cambiado<Return>alterado<Return>. Note cómo esta línea ha cambiado: usted reemplaza la palabra c-a-m-b-i-a-d-o con "alterado" en cada ocurrencia, después de la posición inicial del cursor. * AUTO SALVADO -------------- Cuando usted ha hecho cambios en un archivo, pero usted no ha salvado estos todavía, estos podrían perderse si su sistema deja de funcionar. Para protegerlo de esto, Emacs periódicamente escribe un archivo "auto salvado" para cada archivo que usted está editando. El nombre del archivo auto salvado tiene un # al principio y al final; por ejemplo, si su archivo se llama "hola.c", su archivo auto salvado es "#hola.c#". Cuando usted salva por la vía normal, Emacs borra su archivo de auto salvado. Si el sistema deja de funcionar usted puede recuperar su edición de auto salvado encontrando el archivo normal (el archivo que estuvo editando, no el archivo de auto salvar) y entonces presionando M-x recover file<Return>. Cuando le pregunte por la confirmación, teclee yes<Return> para ir y recuperar la información del auto-salvado. * AREA ECO ---------- Si Emacs ve que usted está presionando comandos de multicaracteres lentamente, este le muestra estos al final de la pantalla en un área llamada "área de eco". El área de eco contiene la línea final de la pantalla. * LÍNEA DE MODO --------------- La línea inmediatamente encima del área de eco es llamada el "línea de modo" dice algo así: --:** TUTORIAL (Fundamental)--l730--58%--------- Esta línea da información útil acerca de el estado de Emacs y del texto que usted está editando. Usted ya sabe qué significa el nombre del archivo -- este es el archivo que usted ha encontrado. --NN%-- indica posición actual en el texto; esto significa que NN porciento del texto está encima de la parte superior de la pantalla. Si el principio del archivo está en la pantalla, este dirá --Top-- en vez de --00%--. Si el final del texto está en la pantalla, este dirá --Bot--. Si usted está mirando un texto tan pequeño que cabe en la pantalla, el modo de línea dirá --All--. La L y los dígitos indican la posición de otra forma: ellos dan el número de línea actual del punto. Las estrellas cerca del frente significan que usted ha hecho cambios al texto. Exactamente despues de que usted visite o salve un archivo, esa parte del modo de línea no muestra estrellas, solo los guiones. La parte del modo de línea dentro de los paréntesis es para indicarle en qué modo de edición está usted. El modo por defecto es Fundamental, el cual es el que usted está usando ahora. Este es un ejemplo de un "modo mayor". Emacs tiene diferentes modos mayores. Algunos de estos están hechos para editar diferentes lenguajes y/o clases de texto, tales como modo Lisp, modo de Texto, etc. En cualquier momento solamente un modo mayor está activo, y su nombre se encuentra siempre en el modo de línea donde "Fundamental" está ahora. Cada modo mayor hace que algunos comandos actúen diferente por ejemplo, hay comandos para crear comentarios en un programa, y como cada lenguaje de programación tiene una idea diferente de cómo debe verse un comentario, cada modo mayor tiene que insertar comentarios de forma distinta. Cada modo mayor es el nombre de un comando extendido, que es como usted puede cambiar a ese modo. Por ejemplo, M-x fundamental-mode es un comando para cambiar al modo fundamental. Si usted va a editar un texto en español, tal como este archivo, probablemente tendrá que usar el modo de texto. >> Teclee M-x text-mode<Return>. No se preocupe, ninguno de los comandos de Emacs que ha aprendido cambia de manera significativa. Pero usted puede ver que M-f y M-b tratan a los apóstrofes como parte de las palabras. Previamente, en modo Fundamental, M-f y M-b trataban los apóstrofes como separadores de palabras. Los modos mayores usualmente hacen cambios sutiles como el anterior: La mayoría de comandos hacen "el mismo trabajo" en cada modo mayor, pero funcionan un poco diferente. Para ver documentación en su modo mayor actual, teclee C-h m. >> Use C-u C-v una vez o mas para llevar esta línea cerca de la parte superior de la pantalla. >> Teclee C-h m, para ver cómo el modo de texto difiere del modo Fundamental. >> Teclee C-x 1 para eliminar la documentación de la pantalla. Los modos mayores son llamados así porque también hay modos menores. Los modos menores no son alternativas para los modos mayores, apenas modificaciones menores de estas. Cada modo menor puede ser activado o desactivado por si mismo, independiente de todos los otros modos menores, e independiente de su modo mayor. Entonces usted puede no usar modos menores, o un modo menor o alguna combinación de varios modos menores. Un modo menor que es muy útil, especialmente para editar textos en inglés, es el modo Auto Fill. Cuando este modo es encendido, Emacs rompe la línea entre palabras automáticamente cuando quiera que inserte texto y haga una línea que es bastante ancha. Usted puede activar el modo Auto Fill al hacer M-x auto fill mode<Return>. Cuando el modo este activado, usted puede desactivarlo nuevamente usando M-x autofill mode<Return>. Si el modo está desactivado, este comando lo activa, y si el modo está activado, este comando lo desactiva. Decimos que el comando "cambia el modo". >> Teclee M-x auto fill mode<Return> ahora. Luego inserte una línea de "asdf " repetidas veces hasta que la vea dividida en dos líneas. Usted debe intercalar espacios porque Auto Fill sólo rompe líneas en espacios. El margen es usualmente puesto en 70 caracteres, pero usted puede cambiarlo con el comando C-x f. Usted debe dar el margen deseado como un argumento numérico. >> Teclee C-x f con un argumento de 20. (C-u 2 0 C-x f). Entonces teclee algún texto y vea como Emacs llena con este líneas de 20 caracteres. Entonces ponga de nuevo el margen a 70 usando otra vez C-x f. Si usted hace cambios en el medio de un párrafo, el modo Auto Fill no lo rellenará por usted. Para rellenar el párrafo, teclee M-q (Meta-q) con el cursor dentro de ese párrafo. >>Mueva el cursor al párrafo anterior y teclee M-q. * BUSCANDO ---------- Emacs puede hacer búsquedas de cadenas (estas son grupos de caracteres contiguos o palabras) hacia adelante a través del texto o para atrás en el mismo. La busqueda de una cadena es un comando de movimiento de cursor; esto mueve el cursor al próximo lugar donde esa cadena aparece. El comando de búsqueda de Emacs es diferente a los comandos de búsqueda de los demás editores, en que este es "incremental". Esto significa que la búsqueda ocurre mientras usted teclea la cadena para buscarla. El comando para iniciar una búsqueda es C-s para búsqueda hacia adelante, y C-r para la búsqueda hacia atrás. PERO ESPERE! no intente esto ahora. Cuando teclee C-s usted verá que la cadena "I-search" aparece como un llamado en el área de eco. Esto le dice que Emacs está en lo que se conoce como búsqueda incremental, esperando que usted teclee la cosa que quiere buscar. <Return> termina una busqueda. >> Ahora teclee C-s para comenzar la búsqueda. LENTAMENTE, una letra a la vez, teclee la palabra 'cursor', haciendo pausa después de cada caracter para notar lo que pasa con el cursor. Ahora ha buscado "cursor", una vez. >> Ahora teclee C-s de nuevo, para buscar la próxima aparición de "cursor". >> Ahora presione <Delete> cuatro veces y mire como se mueve el cursor. >> Teclee <Return> para terminar la búsqueda. Vió lo que ocurrió? Emacs, en una búsqueda incremental, trata de ir a la ocurrencia de la cadena que usted ha tecleado hasta el momento. Para ir a la próxima ocurrencia de "cursor" solo teclee C-s de nuevo. Si tal ocurrencia no existe, Emacs pita y le dice que la búsqueda actual está fallando (failing). C-g también termina la búsqueda. NOTA: En algunos sistemas, oprimir C-x C-s dejará inmovil la pantalla y usted no podra ver más respuesta de Emacs. Esto indica que una "característica" del sistema operativo llamada ''control de flujo'' está interceptando el comando C-s y no permitiéndole llegar a Emacs. Para descongelar la pantalla, presione C-q. Entonces consulte la sección "entrada espontánea para búsqueda incremental'' en el manual de Emacs para encontrar información de cómo tratar con esta "característica". Si usted está en medio de una búsqueda incremental y teclea <Delete>, usted notara que el último caracter de la cadena buscada es borrado y la búsqueda vuelve al último sitio de la búsqueda. Por ejemplo, suponga que usted ha tecleado "c", para buscar la primera ocurrencia de "c". Ahora, si teclea "u", el cursor se moverá a la primera ocurrencia de "cu". Ahora teclee <Delete>. Esto borra la "u" de la cadena buscada, y el cursor vuelve a la primera ocurrencia de "c". Si usted está en medio de una búsqueda y teclea un caracter control o meta (con algunas pocas excepciones-- los caracteres que son especiales en una búsqueda, tales como C-s y C-r), la búsqueda es terminada. El C-s inicia una exploración que busca alguna ocurrencia de la cadena buscada DESPUES de la posición actual del cursor. Si usted quiere buscar algo anterior en el texto, teclee en cambio C-r. Todo lo que hemos dicho sobre C-s también se aplica a C-r, excepto que la dirección de la búsqueda es invertida. * MúLTIPLES VENTANAS -------------------- Una de las agradables características de Emacs es que usted puede mostrar más de una ventana en la pantalla al mismo tiempo. >> Mueva el cursor a esta línea y teclee C-u 0 C-l. >> Ahora teclee C-x 2 que divide la pantalla en dos ventanas. Ambas ventanas muestran este tutorial. El cursor permanece en la ventana superior. >> Teclee C-M-v para desplazar la ventana inferior. (si usted no tiene una tecla Meta real, teclee ESC C-v) >> Teclee C-x o ("o" para "otro") para mover el cursor a la ventana inferior. >> Use C-v y M-v en la ventana inferior para desplazarla. Siga leyendo estas direcciones en la ventana superior. >> Teclee C-x o de nuevo para mover el cursor de vuelta a la ventana superior. El cursor en la ventana superior está justo donde estaba antes. Usted puede continuar usando C-x o Para cambiar entre las ventanas. Cada ventana tiene su propia posición del cursor, pero únicamente una ventana actual muestra el cursor. Todos los comandos de edición comunes se aplican a la ventana en que está el cursor. Nosotros la llamamos "ventana seleccionada". El comando C-M-v es muy útil cuando usted está editando un texto en una ventana y usando la otra ventana como referencia. Usted puede mantener el cursor siempre en la ventana donde está editando, y avanzar a la otra ventana secuencialmente con C-M-v. C-M-v es un ejemplo de un carácter CONTROL-META. Si usted tiene una tecla Meta real, usted puede oprimir C-M-v Sosteniendo a la vez CONTROL y META mientras oprime v. No importa cual tecla oprima primero CONTROL o META. Porque las dos teclas actúan modificando los caracteres que usted digita. Si usted no tiene una tecla META real, y en vez de esta usa ESC, el orden importa: usted debe digitar ESC seguido de Control-v, porque Control-ESC v no trabajará. Esto es porque ESC es un carácter que tiene valor en sí mismo, no es una tecla modificadora. >> digite C-x 1 (en la parte de arriba de la ventana) para deshacerse de la ventana del final. (Si usted hubiera digitado C-X 1 en la ventana inferior, esto eliminaría la superior. Piense en este comando como "mantener sólo una ventana -- la ventana en la cual estoy".) Usted no tiene que mostrar el mismo buffer en ambas ventanas. Si usted usa C-x C-f para encontrar un archivo en una ventana, la otra ventana no cambia. Usted puede encontrar un archivo en cada ventana independientemente. Aquí hay otra forma para usar dos ventanas para mostrar dos cosas diferentes: >> Digite C-x 4 C-f seguido del nombre de uno de sus archivos. Finalice con <Return>. Vea que el archivo especificado aparece en la ventana inferior. El cursor vá allá también. >> Digite C-x o para regresar a la ventana superior, y C-x 1 para borrar la ventana inferior. * NIVELES RECURSIVOS DE EDICIÓN -------------------------------- Algunas veces usted entrará a lo que es llamado un "nivel recursivo de edición". Esto está indicado por paréntesis cuadrados en la línea de modo , rodeando los paréntesis del nombre del modo mayor. Por ejemplo, usted probablemente vea [(Fundamental)] en vez de (Fundamental) Para salir de los niveles recursivos de edición, presione ESC ESC ESC. Este es un comando de "salida" para todo propósito. Usted también lo puede usar para eliminar ventanas extras, y salir del minibuffer. >> Digite M-x para entrar a un minibuffer; Entonces digite ESC ESC ESC para salir. Usted no puede usar C-g para salir de los "niveles recursivos de edición". Esto es porque C-g es usado para cancelar comandos y argumentos DENTRO del nivel recursivo de edición. * CONSIGUIENDO MAS AYUDA ------------------------ En este tutorial hemos tratado de ofrecer suficiente información para que usted empiece a usar Emacs. Hay tanto disponible en Emacs que sería imposible explicar todo aquí, sin embargo, usted puede querer aprender más sobre Emacs, ya que este tiene muchas otras características útiles. Emacs provee comandos para leer documentación acerca de los comandos de Emacs. Estos comandos de "ayuda" todos comienza con el caracter Control-h, que es llamado el caracter de ayuda (help). Para usar las características de ayuda, digite el caracter C-h, y entonces un carácter diciciendo qué tipo de ayuda quiere. Si usted está REALMENTE perdido digite c-h ? y Emacs le dirá qué tipo de ayuda puede ofrecerle. Si usted ha digitado C-h y decide que no quiere ninguna ayuda, digite C-g para cancelarlo. (Algunos sitios cambian el significado del carácter C-h. Ellos realmente no deberían hacer esto como una política para todos los usuarios, así que usted tiene argumentos para quejarse al administrador del sistema. Mientras tanto, sí C-h no muestra un mensaje de ayuda en el final de la pantalla, intente digitar la tecla F1 o en su lugar M-x help <Return>). La característica más básica en la AYUDA es C-h c. Digite C-h, el caracter c y un caracter de comando o una secuencia de comando; entonces Emacs muestra una muy breve descripción del comando. >> Digite C-h c C-p. El mensaje debe ser algo como C-p runs the command previous-line Esto le dice el "nombre de la función". Los nombres de función son usados principalmente para adecuar y extender Emacs. Pero ya que los nombres de las funciones son seleccionados para indicar lo que el comando hace, ellos tambien pueden servir como una breve documentación -- suficiente para recordarle los comandos que ha aprendido. Los comandos de múltiples caracteres tales como C-x C-s y (sí usted no tiene las teclas META o EDIT o ALT) <Esc>v, están permitidos también después de C-h c. Para conseguir más información sobre un comando use C-h k en vez de C-h c. >> Digite C-h k C-p. Esto muestra la documentación de la función, al igual que el nombre, en una ventana de Emacs. Cuando usted haya terminado de leer el resultado, digite C-x 1 para deshacerse del texto de ayuda. No tiene que hacer esto ahora. Usted puede hacer algunas ediciones mientras se refiere al texto de ayuda, y entonces digitar C-x 1. Aquí hay algunas otras opciones útiles de C-h: C-h f Describe una función. Usted digita el nombre de la función. >> Intente digitar C-h f previous-line<Return>. Esto imprime toda la información que Emacs tiene sobre la función que implementa el comando C-p C-h a Comando Apropos. Digite una palabra y Emacs hará una lista de todos los comandos que contengan la palabra digitada. Todos Estos comandos pueden ser invocados con Meta-x. Para algunos comandos, el comando Apropos también listará una secuencia de uno a dos caracteres la cual correrá el mismo comando. >> Digite C-h a file<Return>. Esto muestra en otra ventana una lista de todos los comandos M-x con la palabra "file" en sus nombres. Usted verá comandos de caracteres como C-x C-f listados además de los nombres de los comandos correspondientes tales como find-file. >> Digite C-M-v para desplazar la ventana de ayuda. Haga esto unas pocas veces. >> Digite C-x 1 para borrar la ventana de ayuda. * CONCLUSIÓN ------------ Recuerde, Para salir permanentemente de Emacs use C-x C-c. Para salir a un Shell temporalmente, de forma que usted puede volver a Emacs después, use C-z. Este tutorial intenta ser entendible para todos los usuarios nuevos, así que si encuentra algo confuso, no se siente y se culpe a sí mismo - quéjese! * COPIADO --------- Este tutorial desciende de una larga línea de tutoriales de Emacs comenzando con el escrito por Stuart Cracraft para el Emacs original. La versión en español fue traducida por estudiantes del Gimnasio Fidel Cano (un colegio en Santafé de Bogotá, Colombia): Carlos Alberto López Troncoso Andrés Felipe Mancipe Galvis Lina Fernanda Pinto García Liliana Carolina Quitián Cedeño Leonardo Ramírez Vargas <leonardoramirez(a)latinmail.com> Juan David Vargas Botero <cyberbob1164(a)hotmail.com> Juan Pablo Yela Gallón Jorge Enrique Cárdenas Carrillo <platypus_life(a)hotmail.com> además la versión en español ha sido revisada y corregida por: Pablo Reyes <reyes_pablo(a)hotmail.com> Igor Támara <ikks(a)bigfoot.com> Melissa Giraldo de Támara <melagira(a)yahoo.com> Vladimir Támara <vtamara(a)gnu.org> Por favor, en caso de duda, sólo es válido el original en inglés de la siguiente nota de derechos de reproducción (que puede encontrar en el archivo TUTORIAL). Copyright (c) 1985, 1996 Free Software Foundation Se permite a cualquiera hacer o distribuir copias literales de este documento como se recibe, en cualquier medio, siempre que la nota de derechos de reproducción y la nota de permiso se preserven, y que el distribuidor permita que el que la recibe hacer distribución posterior como lo permite esta nota. Se permite distribuir versiones modificadas de este documento, o porciones de este, bajo las condiciones anteriores, siempre que ellas tengan nota visible especificando quién fue el último en alterarlas. Las condiciones para copiar Emacs mismo son más complejas, pero con el mismo espíritu. Por favor lea el archivo COPYING y entonces distribuya copias de GNU Emacs a sus amigos. Ayude a erradicar el obstruccionismo del software ("propietariedad") usando, escribiendo, y compartiendo software libre! Copyright (c) 1985 Free Software Foundation, Inc; Zie de voorwaarden onderaan. Je leest nu de Emacs uitleg, zoals vertaald door Pieter Schoenmakers. De meeste Emacs commando's gebruiken de CONTROL toets (soms CTRL of CTL genaamd) en/of de META toets (soms genaamd EDIT of ALT). In plaats van steeds de volledige naam te noemen, gebruiken we de volgende afkortingen: C-<chr> betekent: houd de CONTROL toets ingedrukt en type de toets <chr> Dus C-f wordt: houd de CONTROL toets ingedrukt en type f. M-<chr> betekent: houd de META, EDIT of ALT toets ingedrukt en type de toets <chr>. Als er geen toets META, EDIT of ALT is, kun je ook eerst de ESC toets typen, gevolgd door <chr>. We refereren aan de ESC toets als <ESC>. BELANGRIJK: om Emacs te verlaten, type C-x C-c (twee tekens). De tekens ">>" tegen de linker kantlijn nodigen je uit om een bepaald commando te proberen. Bijvoorbeeld: <<Blank lines inserted here by startup of help-with-tutorial>> >> Type nu C-v (volgend scherm) om naar het volgende scherm te gaan. (Geef nu het commando door de control toets ingedrukt te houden terwijl je de v typt.) Vanaf nu moet je dit steeds herhalen als je klaar bent met het lezen van een scherm. Merk op dat er een tweeregelige overlap is als je van een scherm naar het volgende scherm gaat; dit zorgt voor continuiteit bij het lezen van de tekst. Het eerste wat je moet weten is hoe je naar verschillende plaatsen in de tekst kan bewegen. Je weet al hoe je een scherm vooruit moet gaan: met C-v. Om een scherm terug te gaan, type M-v (houd de META toets ingedrukt en type v, of type <ESC>v als je geen META, EDIT of ALT toets hebt). >> Probeer nu een paar keer M-v, steeds gevolgd door C-v. * SAMENVATTING -------------- De volgende commando's zijn handig volledige schermen te bekijken: C-v ga een scherm vooruit M-v ga een scherm terug C-l maak het scherm schoon en teken alle tekst opnieuw, waarbij de regel waarop de cursor staat op het midden van het scherm terecht komt. (C-l is control-L, niet control-1.) >> Kijk waar de cursor is en onthoud de tekst in zijn omgeving. Type C-l. Zoek de cursor en merk op dat 'ie nog steeds bij dezelfde tekst staat. * BASISCOMMANDO'S CURSORBEWEGINGEN ---------------------------------- Het is handig om per scherm te bewegen, maar hoe beweeg je nu naar een specifieke plaats op het scherm? Er is een aantal manieren waarop je dit kan doen. De basismanier is m.b.v de commando's C-p, C-b, C-f en C-n. Elk van deze commando's verplaatst de cursor precies een rij of colomn in een bepaalde richting op het scherm. Hier volgt een figuur met de vier commando's en de richting waarin ze de cursor bewegen: vorige regel, C-p : : achteruit, C-b .... huidige cursorpositie .... vooruit, C-f : : volgende regel, C-n >> Verplaats, m.b.v. C-n of C-p, de cursor naar de middelste regel van de figuur. Type dan C-l om de hele figuur in het midden van het centrum te plaatsen. Met een beetje kennis van het engels zijn deze commando's gemakkelijk te onthouden: de P komt van previous (vorige), de N van next (volgende), de B van backward (achteruit) en de F van forward (vooruit). Dit zijn de basiscommando's om de cursor te bewegen, dus je zult ze CONTINUE gebruiken: Het is slim als je ze nu leert te gebruiken. >> Type een paar keer C-n om de cursor op deze regel te krijgen. >> Beweeg binnen de regel met C-f (herhaaldelijk) en terug omhoog met C-p Let op wat C-P doet als de cursor midden in een regel staan. Elke regel eindigt met een Newline teken (het engelse `new line' betekent `nieuwe regel'); dit teken scheidt elke regel van de volgende. De laatste regel in een bestand moet eigenlijk ook met een Newline eindigen (maar dat is niet noodzakelijk voor Emacs ). >> Type een C-b terwijl de cursor aan het begin van een regel staat. De cursor zal naar het eind van de vorige regel bewegen, omdat je achteruit over het Newline teken gaat. Net als C-b kan ook C-f over Newline tekens heen bewegen. >> Type nog wat C-b's zodat je door krijgt waar de cursor is. Type dan C-f's om terug naar het einde van de regel te bewegen. Een C-f beweegt dan naar de volgende regel. Wanneer je de cursor voorbij het begin of het einde van het scherm beweegt zal de tekst over het scherm heen schuiven. Dit heet `scrollen', of `schuiven' in goed nederlands. Door te scrollen zorgt Emacs ervoor dat de cursor de gewenste beweging kan doen zonder dat de cursor van het scherm af beweegt. >> Probeer de cursor voorbij de onderkant van het scherm te bewegen met C-n en zie wat er gebeurt. Als beweging op karakterbasis te langzaam gaat, kan je ook per woord bewegen. M-f (Meta-f) beweegt een woord vooruit en M-b een woord achteruit. >> Type een paar M-f's en M-b's. Als je midden in een woord staan beweegt M-f naar het eind van het woord. Als je op witruimte tussen woorden staat beweegt M-f naar het eind van het volgende woord. M-b beweegt analoog, de andere kant op. >> Type een paar M-f's en M-b's met tussendoor wat C-f's en C-b's zodat je ziet wat M-f en M-b doen vanaf bepaalde plaatsen in een woord en tussen twee woorden. Merk op dat er een analogie zit tussen enerzijds C-f en C-b en anderzijds M-f en M-b. Het is bij veel commando's zo dat Meta tekens gebruikt worden om iets te doen in eenheden van de taal (woorden, zinnen, paragrafen) terwijl Control tekens te maken hebben met dingen die los staan van wat je aan het editen bent (tekens, regels, etc). Deze analogie gaat ook op voor regels en zinnen: C-a en C-e bewegen naar het begin of eind van een regel, terwijl M-a en M-e naar het begin of eind van een zin gaan. >> Probeer een paar C-a's gevolgd door een paar C-e's. Probeer een paar M-a's gevolgd door een paar M-e's. Zie hoe herhaalde C-a's niets doen, terwijl herhaalde M-a's steeds een zin terug bewegen. Alhoewel ze niet volledig overeenkomen is het gedrag van allebei niet onnatuurlijk. De plaats van de cursor in de tekst wordt `punt' genoemd (zonder lidwoord, `point' in het engels). Anders gezegd: de cursor laat op het scherm de plek zien waarop punt in de tekst staat. Nu volgt een samenvatting van eenvoudige cursorbewegingsoperaties, inclusief die commando's die per woord of zin bewegen: C-f ga een teken vooruit C-b ga een teken achteruit M-f ga een woord vooruit M-b ga een woord achteruit C-n ga naar de volgende regel C-p ga naar de vorige regel C-a ga naar het begin van de regel C-e ga naar het eind van de regel M-a ga terug naar het begin van de zin M-e ga vooruit naar het eind van de zin >> Probeer al deze commando's een paar keer als oefening. Deze commando's worden het frequentst gebruikt. Er zijn nog twee belangrijk cursorbewegingsoperaties: M-< (Meta kleiner-dan) beweegt naar het begin van het bestand, en M-> (Meta groter-dan) beweegt naar het eind. Op de meeste toetsenborden zit de "<" boven de comma, zodat je de Shift toets (ook wel bekend als de hoofdlettertoets) moet gebruiken om het "<" teken in te typen. Op deze toetsenborden moet je ook de shift gebruiken om M-< in te typen: zonder shift zou je M-, (Meta komma) typen. >> Type nu M-< om naar het begin van dit bestand te gaan. Gebruik daarna C-v om hier weer terug te komen. >> Type nu M-> om naar het eind van het bestand te springen. Gebruik daarna M-v om hier weer terug te komen. Als je toetsenbord pijltjestoetsen heeft kan je ook die gebruiken om de cursor te verplaatsen. We raden je aan om C-b, C-f, C-n en C-p op zijn minst te leren, om drie redenen. Ten eerste werken ze op alle toetsenborden, ook die zonder pijltjestoetsen. Ten tweede zul je merken dat, wanneer je eenmaal wat ervaring hebt opgedaan in omgaan met Emacs, het gebruik van deze CTRL tekens sneller is dan de pijltjestoetsen (omdat je handen in de typehouding kunnen blijven). Ten derde, als je eenmaal gewend bent aan deze commando's met CTRL tekens, kan je makkelijk andere geavanceerde cursorbewegingscommandos leren. De meeste Emacs commando's accepteren een numeriek argument. Voor de meeste commando's is dit argument het aantal keren dat het commando herhaald moet worden. Je geeft dit numerieke argument aan door voor het commando, C-u gevolgd door de cijfers van het getal te typen. Als je toetsenbord een META (of EDIT of ALT) toets heeft, is er ook een andere manier om het getal aan te geven: type de cijfers terwijl je de META toets ingedrukt houdt. We raden je aan de C-u manier te leren omdat die werkt op elk willekeurig toetsenbord. Bijvoorbeeld, C-u 8 C-f beweegt de cursor 8 plaatsen naar voren. >> Probeer eens om met C-n of C-p en een numeriek argument de cursor met slechts een commando naar een regel in de buurt van deze zin te bewegen. Voor de meeste commando's is het numerieke argument het aantal keren dat het commando herhaald moet worden. Voor sommige commando's betekent het echter iets anders, en C-v en M-v vallen hier ook onder. Met een numeriek argument verschuiven deze commando's de tekst het aangegeven aantal regels in plaats van (bijna) een heel scherm. Bijvoorbeeld, C-u 4 C-v verschuift de tekst 4 regels. >> Probeer nu C-u 8 C-v. Als het goed is is de tekst daarmee 8 regels opgeschoven. Als je het weer terug omlaag wil scrollen kan je een argument aan M-v geven. Als je een windowing systeem gebruikt, zoals X Windows, dan zou je een lange rechthoek moeten zien aan de linkerkant van het Emacs window. Deze rechthoek heet een scrollbar (misschien is `verschuifbalk' een goede vertaling). Je kan de tekst scrollen door met de muis in de scrollbar te klikken. >> Klik met de middelste muisknop bovenaan het donkere gebied in de scrollbar. Dit zou de tekst moeten scrollen naar een positie die afhankelijk is van hoe hoog of laag je klikt. >> Beweeg de muis heen en weer terwijl je de middelste muisknop ingedrukt houdt. Je zal zien dat de tekst met de muis mee heen en weer scrollt. * ALS EMACS HANGT ----------------- Als Emacs niet meer op commando's reageert kan je haar veilig onderbreken door C-g te typen. Je kan C-g gebruiken om een commando te stoppen als het te lang duurt om uit te voeren. Je kan C-g ook gebruiken om een numeriek argument weg te gooien of om het begin van een commando dat je niet wilt afmaken te vergeten. >> Type nu C-u 100 om een numeriek argument te maken met de waarde 100, en type dan C-g. Type vervolgens C-f. Als het goed is is de cursor maar een positie verplaatst, omdat het argument weggegooid hebt met C-g. Als je per ongeluk een <ESC> typt kan je daarvan komen met een C-g. * ONMOGELIJKE COMMANDO'S ------------------------ Sommige Emacs commando's zijn onmogelijk gemaakt zodat beginnende gebruikers ze niet per ongeluk kunnen uitvoeren. Als je een van de onmogelijke commando's intypt laat Emacs uitleg zien over het commando dat je gegeven hebt en vraagt of je het werkelijk uit wilt voeren. Wanneer je het commando echt wilt uitvoeren, type dan Spatie (de spatiebalk) als antwoord op de vraag. Normaliter wil je het commando niet uitvoeren en beantwoord je de vraag met "n" (van `no' of `nee'). >> Type <ESC> : (een onmogelijk commando), en type dan n als antwoord op de vraag. * VENSTERS ---------- Emacs kan meerdere vensters laten zien, elk venster met zijn eigen tekst. We zullen later uitleggen hoe je met meerdere vensters om kan gaan. Op dit moment willen we slechts uitleggen hoe je van extra vensters af kunt komen en terug kan keren naar simpelweg editen met 1 venster. Het is eenvoudig: C-x 1 een enkel venster (i.e. gooi alle andere vensters weg) Het commando is Control-x gevolgd door het cijfer 1. C-x 1 vergroot het venster waar de cursor in staat tot het hele scherm. Alle andere vensters worden weggegooid. >> Zet de cursor op deze regel en type C-u 0 C-l. >> Type nu Control-h k Control-f. Zie hoe dit venster kleiner wordt, terwijl een nieuw venster verschijnt om de documentatie van het Control-f commando te laten zien. >> Type nu C-x 1 en zie het documentatievenster verdwijnen. * TOEVOEGEN EN WEGHALEN ----------------------- Als je tekst toe wilt voegen type je die eenvoudigweg in. Tekens die je kan zien, zoals A, 7, *, en dergelijke, worden door Emacs als tekst ge-interpreteerd en meteen aan de tekst toegevoegd. Type <Return> (de `volgende regel' toets) om een Newline toe te voegen en dus een nieuwe regel te beginnen. Je kan het laatste teken dat je intypte weghalen door <Delete> te typen. <Delete> is een toets op het toetsenbord, die misschien ook wel "Del" heet. In sommige gevallen dient de "Backspace" toets als <Delete>, maar niet altijd! In het algemeen haalt <Delete> het teken dat juist voor de cursorpositie staat weg. >> Probeer dit nu: type een paar letters en haal ze weer weg door een paar keer op <Delete> te drukken. Maak je niet druk over het feit dat dit bestand verandert; je zal niets veranderen aan de originele versie van deze uitleg. Je zit slechts je eigen copie te wijzigen. Als een regel tekst te lang wordt om op een regel op het scherm te laten zien dan gaat de regel verder op een volgende schermregel. Een backslash ("\") in de rechtermarge laat dan zien dat de regel op de volgende schermregel verder gaat. >> Voeg nu tekst toe totdat je de rechter kantlijn raakt, en blijf toevoegen. Je zal zien dat er een vervolgregel verschijnt. >> Type weer wat <Delete>s om zoveel tekens weg te halen tot de regel weer op een schermregel past. De vervolgregel zal verdwijnen. Je kan een Newline weggooien als elk ander teken. Als je een Newline weggooit voeg je de twee regels waar de Newline tussen staat samen tot een enkele regel. Als de regel die het resultaat is van deze operatie niet op een schermregel past zal ze getoond worden met een vervolgregel. >> Beweeg de cursor naar het begin van een regel en type <Delete>. Dit voegt de huidige en vorige regel samen. >> Type <Return> om de Newline die je net weggooide weer toe te voegen. Je herinnert je dat je bij de meeste Emacs commando's het aantal keren dat het herhaald moet worden op kan geven. Dit geldt ook voor gewone tekens. Als je een gewoon teken herhaalt wordt dat teken herhaaldelijk toegevoegd. >> Probeer dat nu: type C-u 8 * om ******** toe te voegen. Je hebt nu de basismanier geleerd om iets in Emacs te typen en fouten te corrigeren. Je kan tekst ook per woord of regel weggooien. Hier volgt een samenvatting van de commando's om tekst te verwijderen: <Delete> haal het teken weg dat voor de cursor staat C-d haal het teken weg dat achter de cursor staat M-<Delete> gooi het woord weg dat voor de cursor staat M-d gooi het woord weg dat achter de cursor staat C-k gooi alles weg van de cursor tot het eind van de regel M-k gooi alles weg van de cursor tot het eind van de zin Merk op dat <Delete> en C-d met M-<Delete> en M-d de analogie die begon met C-f en M-f verder trekken (waarbij we voor het gemak even vergeten dat <Delete> niet echt een control teken is). C-k en M-k lijken enigzins op C-e en M-e in hun relatie tot regels en zinnen. Als je meer dan een enkel teken tegelijk weghaalt bewaart Emacs de tekst die je weggooit zodat je haar weer terug kan halen. Weggegooide tekst terughalen heet "yanken". Je kan weggegooide tekst terugbrengen op de plaats waar je haar hebt weggegooid of op een andere plaats in de tekst. Je kan ook meerdere keren yanken om er meedere copi-en van te maken. Het yank-commando is C-y. Merk op dat er een verschil is tussen het weghalen en weggooien van iets: iets dat je hebt weggooid kan je terugbrengen, maar iets dat je hebt weggehaald niet. (In het engels is het verschil tussen `killing' en `deleting' duidelijker dan tussen de nederlandse vertaling `weggooien' en `weghalen'.) In het algemeen geldt dat de commando's die meer tekst dan een enkel teken, Newline of spatie verwijderen deze tekst bewaren zodat ze geyankt kan worden, terwijl dat niet geldt voor commando's die slechts een enkel teken weghalen. >> Zet de cursor op het begin van een regel die niet leef is. Type C-k om de tekst op die regl weg te gooien. >> Type C-k een tweede keer. Nu gooit dit commando het Newline teken weggooit. Merk op hoe een enkele C-k de inhoud van een regel weggooit, een tweede C-k de regel zelf zodat alle volgende regels een regel omhoog komen. Het numerieke argument is voor C-k bijzonder: het aangegeven aantal regels zal worden weggegooid, inclusief de inhoud. Dit is meer dan simpelweg herhaling: C-u 2 C-k gooit twee regels weg, terwijl tweemaal C-k typen dat niet doet. Om de laatst weggegooide tekst terug te halen naar de plaats waar de cursor nu op staat (te yanken), type C-y. >> Probeer het nu: type C-y om de tekst te yanken. Het is alsof je met C-y iets uit de prullenbak haalt wat je net had weggegooid. Merk op dat verschillende C-k's achter elkaar alle regels die weggegooid worden bij elkaar bewaart zodat een enkele C-y die regels in een keer terugbrengt. >> Probeer het nu: type C-k een paar keer. Om de weggegooide tekst terug te halen: >> Type C-y. Beweeg de cursor wat regels naar beneden en type weer C-y. Je ziet nu hoe je tekst kan copieren. Wat nu te doen als je wat tekst terug wilt brengen, maar je hebt intussen al iets anders weggegooid? C-y zou datgene terugbrengen wat je het recentst hebt weggegooid. Gelukkig is de voorgaande tekst niet verloren gegaan. Je kunt die tekst terughalen met M-y. Nadat je C-y hebt getypt om de recentst weggegooide tekst terug te halen, vervangt M-y die tekst met de tekst die je daarvoor had weggegooid. Je kunt M-y herhalen om tekst terug te halen die je steeds langer geleden hebt weggegooid. Als je de tekst te pakken hebt die je zocht hoe je niets te doen om die daar te houden. Je kan gewoon verder werken en de teruggehaalde tekst met rust laten. Als je M-y vaak genoeg typt kom je terug waar je begon, bij de recentst weggegooide tekst. >> Gooi een regel weg, beweeg de cursor wat, en gooi nog een regel weg. Type C-y om de tweede regel die je weggooide terug te halen. Type nog een M-y en die regel wordt vervangen door de eerste regel die je weggooide. Type nog wat M-y's en zie wat er langs komt. Herhaal dit tot de tweede regel weer langs komt, en dan nog een paar keer. Je kan ook experimenteren met positieve en negatieve argumenten aan M-y. * HERSTELLEN ------------ Als je de tekst veranderd hebt en je daar toch niet tevreden mee bent, dan kan je de verandering ongedaan maken met het herstel commando, C-x u. Normaal gesproken herstelt C-x u de veranderingen die het gevolg zijn van een enkel commando; door herhaaldelijk C-x u te typen, worden steeds eerdere commando's hersteld. Er zijn echter twee uitzonderingen: commando's die de tekst niet wijzigen, zoals cursorbewegingen, worden overgeslagen, en commando's die simpelweg de ingetypte letter aan de tekst toevoegen worden meestal gegroepeerd in groepjes van maximaal 20 tekens, zodat je minder C-x u's hoeft te type om het toevoegen van teksts te herstellen. >> Gooi deze regel weg met C-k; met C-x u zou ze weer moeten verschijnen. C-_ is een alternatief voor C-x u. Het levert exact hetzelfde resultaat op, maar is makkelijker om een paar keer achter elkaar te typen. Een nadeel van C-_ is dat op sommige toetsenborden het intypen ervan niet triviaal is. Dat is ook de reden het alternatief, C-x u. Op sommige terminals kan je C-_ typen door te doen alsof je C-/ typt. Een numeriek argument aan C-_ of C-x u duidt het aantal herhalingen aan. * BESTANDEN ----------- Om een tekst die je gemaakt of veranderd hebt op te slaan moet je de tekst in een bestand bewaren (`to save a file' in het engels). Als je dat niet doet ben je die veranderingen kwijt op het moment dat je uit Emacs gaat. Je kan een bestand veranderen door het bestand `bezoeken'. (Ook wel `vinden'; `finding' of `visiting' in het engels.) Het bezoeken van een bestand betekent dat je de inhoud van dat bestand in Emacs ziet. Het lijkt er dan op alsof je het bestand aan het veranderen bent. Echter, deze veranderingen zijn slechts tijdelijk zolang je het bestand niet bewaart. Op deze manier kan je nooit per ongeluk een half gewijzigd bestand op het systeem achterlaten. Zelfs als je het bestand bewaart, zorgt Emacs ervoor dat het originele bestand onder een gewijzigde naam nog steeds beschikbaar is, voor het geval je later besluit dat de veranderingen toch niet zo'n goed plan waren. In de buurt van de onderkant van het scherm zie je een regel die begint en eindigt met streepjes, met aan het begin "--:-- TUTORIAL.nl" of iets dergelijks. Dit deel van het scherm laat normaal de naam van het bestand zien dat je op dat moment bezoekt. Op dit moment bezoek je een bestand dat "TUTORIAL.nl" heet; het is je eigen copie van de nederlandstalige Emacs uitleg (`tutorial' in het engels). Als je in Emacs een bestand bezoekt dan staat de naam van het bestand altijd op deze plaats. De commando's om een bestand te bezoek of te bewaren zijn anders dan de commando's die je tot nu toe geleerd hebt; ze bestaan namelijk uit twee tekens. Beide commando's beginnen met het teken Control-x. Er zijn een heleboel commando's die met Control-x beginnen. Veel van die commando's hebben te maken met bestanden, buffers, en daaraan gerelateerde zaken. Dergelijke commando's bestaan uit twee, drie of vier tekens. Nog iets bijzonders aan het commando om een bestand te bezoeken is dat je aan moet geven welk bestand je wilt. Dit heet dat het commando "een argument van de gebruiker vraagt"; in dit geval de naam van het bestand. Nadat je het commando C-x C-f bezoek bestand (met de f van `find file') hebt getypt vraagt Emacs om de naam van het bestand. De naam die je intypt verschijnt op de onderste regel van het scherm. Wanneer die regel voor dit soort invoer gebruikt wordt, heet ze de minibuffer. Je kan de gebruikelijke Emacs commando's gebruiken om de filename in te typen. Tijdens het invoeren van de naam van het bestand (of willekeurig wat voor minibuffer invoer) kan je het commando afbreken met C-g. >> Type C-x C-f gevolgd door C-g. Dit breekt de minibuffer af en ook het C-x C-f commando dat van de minibuffer gebruik maakte. Netto resultaat is dat je geen bestand bezoekt. Als je de naam van een bestand hebt ingevoerd, type dan <Return> om het af te sluiten. Hierna gaat het C-x C-f commando aan het werk en bezoekt het bestand dat je aangegeven hebt. Als het C-x C-f commando klaar is, verdwijnt de minibuffer. Na korte tijd verschijnt de inhoud van het bestand op het scherm en kan je de inhoud wijzigen. Als je de wijzigingen op wilt slaan, type dan het commando C-x C-s bewaar bestand (met de s van `save file') Dit bewaart de tekst zoals Emacs die nu heeft in het bestand. De eerste keer dat je dit doet bewaart Emacs het originele bestand onder een andere naam zodat het nog niet verloren is. De nieuwe naam bestaat uit de oude naam gevolgd door een "~". Als Emacs klaar is het bestand te bewaren laat ze de naam van het bestand zien. Het is een goede gewoonte een bestand redelijk vaak te bewaren zodat er niet teveel werk verloren gaat als het systeem hangt of crasht. >> Type C-x C-s, om je copie van deze uitleg te bewaren. Als het goed is verschijnt "Wrote ...TUTORIAL" op de onderste schermregel. OPMERKING: Op sommige systemen gebeurt er helemaal niets als je C-x C-s typt, en daarna ook niets meer. Dit komt door een eigenschap van de machine waarop je werkt die te maken heeft met `flow control'. Met C-s stopt de `flow' en komt niets meer van wat je typt bij Emacs terecht. Om deze situatie te herstellen, type C-q. Lees daarna de "Spontaneous Entry to Incremental Search" sectie in het Emacs handboek over hoe om te gaan met deze situatie. Je kan een bestaand bestand bezoeken, om het te bekijken of het te wijzigen. Je kan ook een bestand bezoeken dat nog niet bestaat. Dit is de manier om met Emacs een nieuw bestand te maken: bezoek het bestand, dat initieel leeg zal zijn, en voeg tekst toe. Zodra je de tekst bewaart wordt het bestand werkelijk gecreeerd, met de tekst als inhoud. Vanaf dat moment ben je dus bezig met een bestaand bestand. * BUFFERS --------- Als je een tweede bestand bezoekt met C-x C-f blijft het eerste bestand gewoon in Emacs. Je kan naar dat bestand terug door het gewoon nog een keer te bezoeken met C-x C-f. Op deze manier kan je een behoorlijk aantal bestanden in Emacs krijgen. >> Cre-eer een bestand dat "foo" heet door te typen: C-f C-f foo <Return>. Voeg hieraan wat tekst toe, wijzig haar, en bewaar "foo" door C-x C-s te typen. Type hierna C-x C-f TUTORIAL <Return> om weer hier, in de uitleg, terug te komen. Emacs bewaart intern de tekst van elk bestand in een ding dat een "buffer" genoemd wordt. Als je een bestand bezoekt wordt er een nieuwe buffer gemaakt. Om een lijst van de huidige buffers te zien, type C-x C-b laat de bufferlijst zien >> Probeer C-x C-b nu. Zie dat elke buffer een naam heeft en mogelijk ook een bestandsnaam; dit is de naam van het bestand waarmee de buffer overeenkomt. Sommige buffers hebben niets met een bestand te maken. Bijvoorbeeld, de buffer die "*Buffer List*" heet heeft geen bestand. Die buffer is de buffer die de lijst bevat die door C-x C-b gemaakt wordt. ALLE tekst die je in een Emacs venster ziet is altijd onderdeel van een of andere buffer. >> Type C-x 1 om de bufferlijst te verwijderen. Als je de tekst van het ene bestand verandert en dan een ander bestand bezoekt dan wordt het eerste bestand niet bewaard. De wijzigingen blijven in Emacs, in de buffer die bij het bestand hoort. Het cre-eren of modificeren van de buffer van het tweede bestand heeft geen effect op de eerste buffer. Dit is erg nuttig, maar betekent ook dat er een eenvoudige manier nodig is om het eerste bestand te bewaren. Het zou erg vervelend zijn om er eerst naar terug te moeten gaan met C-x C-f om het dan te kunnen bewaren met C-x C-s. Dus hebben we C-x s bewaar een paar buffers C-x s vraagt voor elke buffer die veranderingen heeft die nog niet opgeslagen zijn, of je de buffer wilt bewaren. >> Voeg een wat tekst toe en type C-x s. Emacs vraagt nu of je de buffer die TUTORIAL.nl heet wilt bewaren. Bewantwoord deze vraag positief door een "y" in te typen (de y van "yes", engels voor "ja"). * UITGEBREIDE COMMANDO'S ------------------------ Er zijn veel meer Emacs commando's dan er op de toetsen van het toetsenbord passen, zelfs als we hun aantal kunnen vergroten door de control of meta toets te gebruiken. Emacs lost dit probleem op met het X commando (met de X van eXtensie of uitbreiding). Het X commando komt in twee smaken: C-x teken eXtensie; wordt gevolgd door een teken M-x genaamd commando eXtensie; wordt gevolgd door een naam. Deze commando's zijn in het algemeen nuttig, maar worden minder gebruikt dan de commando's die tot nu toe uitgelegd zijn. Je hebt al twee van deze commando's gezien: C-x C-f om een bestand te bezoeken, en C-x C-s om het te bewaren. Een ander voorbeeld is het commando om Emacs te verlaten: dit is C-x C-c. (Maak je geen zorgen over het verloren gaan van veranderingen die niet bewaard zijn; C-x C-c vraagt of je veranderde buffers wilt bewaren voordat Emacs daadwerkelijk eindigt.) C-z is het commando om Emacs *tijdelijk* te verlaten, zodat je daarna weer terug kan keren in dezelfde Emacs sessie. Op systemen die deze mogelijkheid bieden, zet C-z Emacs stil: je komt weer terug in de shell, maar Emacs is nog aanwezig. In de meeste shells kan je Emacs weer activeren met het "fg" commando, of met "%emacs". Op systemen die niet de mogelijkheid bieden om programma's stil te zetten cre-eert C-z een subshell onder Emacs om je zo in de gelegenheid te stellen andere programma's uit te voeren en daarna weer in Emacs terug te keren; Emacs wordt dus niet werkelijk verlaten. In dit geval is het shellcommando "exit" de normale manier om de subshell te verlaten en in Emacs terug te keren. Het moment om C-x C-c te gebruiken is wanneer je uit gaat loggen. Het is ook het juiste commando om Emacs te be-eindigen wanneer Emacs opgestart was door een mail programma of iets dergelijks, aangezien die misschien niet met een stilgezette Emacs om kunnen gaan. Normaal gezien is het echter beter Emacs stil te zetten met C-z dan om Emacs te verlaten, behalve als je uit wilt loggen natuurlijk. Er bestaan vele C-x commando's. Hier is een lijst van degene die je nu al kent: C-x C-f bezoek bestand C-x C-s bewaar bestand C-x C-b laat bufferlijst zien C-x C-c verlaat Emacs C-x u herstel Genaamde uitgebreide commando's worden nog minder vaak gebruikt, of worden alleen onder bepaalde omstandigheden gebruikt. Een voorbeeld is het commando replace-string, dat in de hele tekst een string vervangt door een andere string (`to replace' betekent `vervangen'). Als je M-x typt echoot Emacs onderaan het scherm `M-x' en moet je de naam van het commando intypen, in dit geval "replace-string". Als je gewoon "repl s<TAB>" typt maakt Emacs de naam zelf af. Be-eindig het commando met <Return>. Het replace-string commando heeft twee argumenten nodig: de string die vervangen moet worden en de string waarmee die vervangen moet worden. Je sluit elk argument af met <Return>. >> Plaats de cursor op de lege regel twee regels onder deze. Type dan M-x repl s<Return>gewijzigd<Return>veranderd<Return>. Zie hoe deze regel daardoor gewijzigd is. Je hebt elk voorkomen van het woord g-e-w-i-j-z-i-g-d vervangen door "veranderd"; beginnend op de plek waar de cursor staat. * AUTOMATISCH BEWAREN --------------------- Als je een bestand veranderd hebt maar het nog niet bewaard hebt, zouden de veranderinge verloren kunnen gaan als het systeem zou hangen of herstarten. Om je hiertegen te beschermen bewaart Emacs om de zoveel tijd de veranderde tekst automatisch. De naam van het bestand waarin de tekst automatisch bewaard wordt begint en eindigt met een #. Bijvoorbeeld, als je het bestand "hello.c" aan het bewerken bent dan wordt de tekst automatisch bewaard in een bestand dat "#hello.c#" heet. Zodra je het bestand werkelijk bewaart, wordt het automatisch bewaarde bestand weer weggegooid. Als de computer crasht kan je de automatisch bewaarde tekst terugkrijgen door de file normal te bezoeken (de originele file, niet de automatisch bewaarde), gevolgd door M-x recover file<Return>. Als Emacs vraagt om bevestiging, antwoord dan yes<Return> en de automatisch bewaarde informatie wordt teruggehaald. * ECHO GEBIED ------------- Als je een commando langzaam intypt echoot Emacs de tekens aan de onderkant van het scherm, in een deel dat het "echo gebied" genoemd wordt. Dit gebied bevat de onderste regel van het scherm. * MODE-REGEL ------------ De regel direct boven het echo gebied heet de "mode-regel". De mode-regel zier er ongeveer zo uit: --**-Emacs: TUTORIAL.nl (Fundamental)--68%------------------------ Deze regel geeft interessante informatie over Emacs en de tekst die je aan het bewerken bent. Je weet al wat de bestandsnaam betekent: het is de naam van het bestand dat je bezoekt. -NN%-- geeft je huidige positie in de tekst aan: NN procent van de tekst bevindt zich boven het scherm. Als het bestand vanaf het begin op het scherm staat, staat er --Top-- in plaats van --00%--. Als het laatste stuk tekst op het scherm staat, zal er --Bot-- staan (van `bottom', `onderkant' in het nederlands). Als de tekst zo klein is dat ze volledig op het scherm past staat --All-- in de mode-regel. De sterretjes aan het begin betekenen dat je de tekst gemodificeerd hebt. Direct na het bezoeken of bewaren staan er gewoon streepjes. In de mode-regel staat tussen haakjes in welke mode je aan het werken bent. Tenzij een andere mode gewenst is, zit je in de "Fundamental" mode zoals nu (`fundamental' is `basis' in het nederlands). Een dergelijke mode heet een hoofdmode (`major mode' in het engels). Emacs heeft verschillende hoofdmodes. Sommige daarvan zijn bedoelt voor het bewerken van verschillende talen of soorten tekst, zoals bijvoorbeeld Lisp mode, Text mode, etc. Op elk moment is er altijd precies een mode actief, en de naam daarvan staat in de mode-regel, op de plaats waar nu "Fundamental" staat. Elke hoofdmode zorgt ervoor dat sommige commando's zich anders gedragen. Zo bestaat er een commando om een commentaar in een programma te typen, en aangezien elke programmeertaal een ander idee heeft over hoe commentaar eruit moet zien, moet elke hoofdmode op een andere manier het commentaar beginnen. Elke hoofdmode is de naam van een uitgebreid commando, en met dat commando schakel je om naar die hoofdmode. Zo is bijvoorbeeld M-x fundamental-mode het commando om naar de basismode om te schakelen. Als je nederlandse of engelse tekst wil gaan bewerken, zoals bijvoorbeeld dit bestand, kan je beter "text mode" gebruiken, de mode om tekst in een gewone taal te bewerken: >> Type M-x text-mode<Return>. Wees gerust; geen van de commando's die je geleerd hebt zorgen voor grondige veranderingen in Emacs. Een van de dingen die je kan merken is bijvoorbeeld dat M-f en M-b nu apostrophes als onderdeel van een woord beschouwen. In de vorige, Fundamental, mode behandelen M-f en M-b de apostrophe als ruimte tussen twee woorden. Het is gebruikelijk dat hoofdmodes dergelijke subtiele verschillen hebben. De meeste commando's doen dus min of meer hetzelfde in elke hoofdmode. Met het commando C-h m kan je de documentatie over de huidige hoofdmode lezen. >> Gebruik C-u C-v een paar keer om deze zin in de buurt van de bovenkant van het scherm te krijgen. >> Type C-h m om te zien hoe Text mode verschilt van Fundamental mode. >> Type C-x 1 om de documentatie van het scherm te verwijderen. Hoofdmodes heten hoofdmodes omdat er ook bijmodes zijn. Bijmodes zijn geen alternatieven voor hoofdmodes; het zijn slechts kleine modificaties daarvan. Elke bijmode kan aan- of uitgezet worden, onafhankelijk van andere bijmodes en onafhankelijk van de hoofdmode. Je kan dus nul, een, of willekeurig veel minor modes gebruiken. Een nuttige bijmode voor het bewerken van tekst in een natuurlijke taal, zoals nederlands, is Auto Fill mode (`auto fill' betekent automatisch uitvullen). Wanneer deze mode aanstaat breekt Emacs automatisch een regel tussen twee woorden af als de regel anders te lang zou worden. Je kan Auto Fill mode aanzetten met M-x auto-fill-mode<Return>. Als deze mode al aanstaat, kan je hem uitzetten met M-x auto-fill-mode<Return>. Als de mode uitstaat zet dit commando de mode aan; als ze aanstaat zet dit commando de mode uit. Het commando zet de mode steeds aan en uit zet (`to toggle' in het engels). >> Type nu M-x auto-fill-mode<Return>. Type nu vele malen asdf op een regel zodat je kan zien dat de regel in twee-en gesplitst wordt. Er moeten wel spaties tussen de woorden staan, omdat de Auto Fill mode alleen op spaties de regel breekt. De rechter kantlijn staat meestal op 70 tekens, maar die kan je veranderen met het C-x f commando. Dit commando accepteert een numeriek argument dat de gewenste kantlijn is. >> Type C-x f met 20 als argument (C-u 20 C-x f). Type wat tekst en zie dat Emacs de regels afbreekt bij 20 tekens. Zet de kantlijn nu terug op 70, weer met C-x f. Als je de tekst midden in een regel verandert vult Auto Fill mode de regel niet opnieuw. Om een paragraaf opnieuw te vullen, type M-q (Meta-q) terwijl de cursor in de paragraaf staat. >> Plaats de cursor in de voorgaande paragraaf en type M-q. * ZOEKEN -------- Emacs kan strings zoeken (een string is een rij tekens), zowel volgend op de cursorpositie, als eraan voorafgaand. Het zoeken van een string verplaatst de cursor naar de volgende plaats waar de gezochte string voorkomt. Het zoekcommando van Emacs is anders dan de zoekcommando's van de meeste tekstverwerkers; het zoekt incrementeel. Dit betekent dat het zoeken gebeurt tijdens het intypen van de gezochte string. Het commando om vooruit zoeken te starten is C-s (met de `s' van `to search', i.e. zoeken); C-r start het zoeken achteruit (met de `r' van `reverse' of achteruit). WACHT nog even met ze te proberen. Als je C-s typt verschijnt de string "I-search" in het echo gebied. Dit betekent dat Emacs bezig is met een `incremental search' (incrementele zoekopdracht) en wacht op het intypen van de zoekstring. <RET> be-eindigt het zoeken. >> Type nu C-s om het zoeken te start. Type nu, LANGZAAM, een letter per keer, het woord `cursor', met een pauze na elke letter zodat je kan zien wat er met de cursor gebeurt. Je hebt nu eenmaal naar het woord `cursor' gezocht. >> Type nogmaals C-s, om naar het volgende voorkomen van `cursor' te zoeken. >> Type nu viermaal <Delete> en let op de cursorbewegingen. >> Type <RET> om het zoeken te be-eindigen. Zag je wat er gebeurde? Tijdens incrementeel zoeken probeert Emacs naar de eerste plek te gaan waar de string staat die je tot dan toe getypt hebt. Om naar de volgende plek te gaan, type je C-s nog een keer. Als er geen volgende plek is piept Emacs en vertelt je dat de zoekopdracht faalt (`failing' in het engels); met C-g kan je het zoeken afbreken. OPMERKING: Op sommige systemen gebeurt er helemaal niets als je C-x C-s typt, en daarna ook niets meer. Dit komt door een eigenschap van de machine waarop je werkt die te maken heeft met `flow control'. Met C-s stopt de `flow' en komt niets meer van wat je typt bij Emacs terecht. Om deze situatie te herstellen, type C-q. Lees daarna de "Spontaneous Entry to Incremental Search" sectie in het Emacs handboek over hoe om te gaan met deze situatie. Als je tijdens incrementeel zoeken <Delete> typt, zal je zien dat het laatste teken dat je in de zoekstring typte weggehaald wordt en dat het zoeken teruggaat naar de voorgaande plaats. Als je bijvoorbeeld begint met zoeken en je typt een "c" dan ga je naar het eerste voorkomen van een "c". Type je vervolgens een "u" dan gaat de cursor naar het eerste voorkomen van de string "cu". Als je nu <Delete> typt, dan wordt de "u" van de zoekstring afgehaald en gaat de cursor terug naar de plaats waar hij stond voordat je de "u" intypte, i.e. het eerste voorkomen van de "c". Als je tijdens een zoekoperatie een control- of meta-teken intypt dan wordt het zoeken be-eindigd. Er zijn een paar uitzonderingen, namelijk tekens die tijdens zoeken een speciale betekenis hebben, zoals C-s en C-r. Met C-s begin je te zoeken naar het eerste voorkomen van de zoekstring NA de huidige cursorpositie. Als je iets wilt zoeken dat eerder in de tekst moet voorkomen, gebruik dan C-r i.p.v. C-s. Alles wat we nu weten over C-s geldt ook voor C-r, alleen de zoekrichting is omgedraaid. * MEERDERE VENSTERS ------------------- Een van Emacs' aardige eigenschappen is dat je meerdere vensters op het scherm kan laten zien. >> Zet de cursor op deze regel en type C-u 0 C-l. >> Type C-x 2 om het scherm in twee vensters op te splitsen. Beide vensters laten deze uitleg zien; de cursor blijft in het bovenste venster. >> Type C-M-v om de tekst in het onderste venster te verschuiven. (Als je geen Meta toets hebt, type dan ESC C-v.) >> Type C-x o (met de `o' van `other'; `ander' in het nederlands) om de cursor naar het andere venster te verplaatsen. >> Verschuif de tekst in het onderste venster, m.b.v. C-v en M-v. Zorg ervoor dat je deze uitleg in het bovenste venster leest. >> Type weer C-x o om de cursor weer in het bovenste venster te zetten. De cursor staat weer precies op de plaats waar hij stond toen je het venster verliet. Je kan C-x o blijven gebruiken om van venster naar venster te gaan. Elk venster heeft zijn eigen cursorpositie; de cursor is altijd maar zichtbaar in een daarvan. Alle normale commando's hebben betrekking op het venster waar de cursor in staat. Dit venster is het `geselecteerde venster' (`selected window' in het engels). Het C-M-v commando is erg nuttig wanneer je tekst aan het bewerken bent in het ene venster, terwijl je het andere venster als referentie gebruikt. Je kan de cursor dan altijd in het venster houden waarin je bezig bent, terwijl je met C-M-v door de tekst in het andere venster loopt. C-M-v is een voorbeeld van een CONTROL-META teken. Als je een echte META toets hebt kan je C-M-v intypen door zowel CTRL als META ingedrukt te houden terwijl je v typt. Het maakt niet uit in welke volgorde je de CTRL en META indrukt; het gaat erom welke ingedrukt zijn terwijl je typt. Als je geen echte META toets hebt kan je ESC gebruiken; de volgorde maakt dan wel uit. Je moet dan ESC typen, gevolgd door CTRL-v; CTRL-ESC v zal niet werken. Dit komt doordat ESC zelf een teken is, terwijl CTRL en META dat niet zijn. >> Type C-x 1 (in het bovenste venster) om het onderste venster te laten verdwijnen. (Als je C-x 1 typt in het onderste venster laat je het bovenste verdwijnen. C-x 1 betekent zoveel als `ik wil maar 1 venster, en wel dat venster waar de cursor nu in staat.') Hier is nog een manier om twee venster te krijgen die elk een andere tekst laten zien: >> Type C-x 4 C-f gevolgd door de naam van een van je bestanden, gevolgd door <Return>. Het opgegeven bestand zal in het onderste venster verschijnen, en de cursor zal in dat venster staan. >> Type C-x o om terug naar het bovenste venster te gaan, en C-x 1 om het onderste venster te laten verdwijnen. * RECURSIEVE BEWERKINGSNIVEAUS ------------------------------ Soms kom je in Emacs in een recursief bewerkingsniveau terecht (engels: `recursive editing level'). Dit is te zien in de moderegel aan de rechte haken om de haakjes die om naam van de hoofdmode staan. Dan staat er bijvoorbeeld [(Fundamental)] in plaats van (Fundamental). Type ESC ESC ESC Om uit een recursief bewerkingsniveau te komen. Dit is een generiek `ontsnappingscommando'. Je kan het ook gebruiken om extra vensters weg te gooien of om uit de minibuffer te komen. >> Type M-x om in een minibuffer te komen, en type dan ESC ESC ESC om er weer uit te komen. C-g is niet bruikbaar om uit een recursief bewerkingsniveau te komen. De reden hiervoor is dat C-g gebruikt wordt om commando's af te breken BINNEN het recursieve bewerkingsniveau. * MEER INFORMATIE ----------------- We hebben geprobeerd je met deze uitleg precies genoeg informatie te geven om met Emacs te beginnen. De mogelijkheden van Emacs zijn zo legio dat het onmogelijk is nu alles uit te leggen. Emacs heeft zoveel nuttige mogelijkheden dat je er meer over zou kunnen willen leren. Emacs heeft commando's om documentatie te laten zien over Emacs commando's. Deze `helpcommando's' beginnen allemaal met C-h: `het Hulpteken'. Om hulp te krijgen, type C-h, gevolgd door een teken om aan te duiden welke hulp je wilt. Als je het echt niet meer weet, type C-h ? en Emacs vertelt welke hulp het allemaal te bieden heeft. Als je C-h hebt getypt maar van gedachten veranderd bent, type je gewoon C-g om het af te breken. (Op sommige computers is de betekenis van C-h veranderd. Dat is een slecht plan, zeker als die verandering op alle gebruikers invloed heeft, en is dus een geldige reden om je beklag te doen bij de systeembeheerder of helpdesk. Als C-h intussen niet een bericht onderaan het scherm laat zien over mogelijke hulp, probeer dan de F1 toets (functietoets 1) of gebruik M-x help RET.) De eenvoudigste hulp is C-h c. Type C-h, het teken `c' en een teken of uitgebreid commando, en Emacs laat een zeer korte beschrijving van het commando zien. >> Type C-h c Control-p. De beschrijving die getoond wordt zou zoiets moeten zijn als C-p runs the command previous-line (nederlands: C-p voert het commando previous-line uit.) Dit commando vertelt je `de naam van de functie'. Functies worden vooral gebruikt om Emacs uit te breiden of aan de wensen van de gebruiker aan te passen. Aangezien functienamen gekozen zijn om aan te geven wat de functie doet, zijn ze ook geschikt als erg korte documentatie; genoeg om je te herinneren aan wat de commando's die je al geleerd hebt betekenen. Uitgebreide commando's zoals C-x C-s en (als je geen META, EDIT or ALT toets hebt) <ESC> v kunnen ook getypt worden na C-h c. Om meer informatie over een commando te krijgen, type C-h k in plaats van C-h c. >> Type C-h k Control-p. Dit laat de documentatie van de functie zien, inclusief de naam van de functies, in een apart venster. Als je klaar bent met lezen, type C-x 1 om van dat venster af te komen. Je hoeft dat natuurlijk niet meteen te doen. Je kan ook eerst wat anders doen voordat je C-x 1 typt. Hier zijn nog wat nuttige mogelijkheden van C-h: C-h f Beschrijf een functie. Je moet de naam van de functie intypen. >> Type C-h f previous-line<Return> Dit laat alle informatie zien die Emacs heeft over de functie die het C-p commando implementeert. C-h a Commando Apropos. Type een woord in en Emacs zal een lijst van alle commando's laten zien waarin dat woord voorkomt. Al deze commando's kunnen aangeroepen worden met M-x. Bij sommige commando's staat met welke tekens dit commando direct uitgevoerd kan worden. >> Type C-h a file<Return>. Dit laat in een ander venster alle M-x commando's zien met `file' in hun naam. Je zal teken-commando's zien als C-x C-f naast de overeenkomende commandonaam zoals find-file. >> Type C-M-v herhaaldelijk om de tekst in het hulpvenster te verschuiven. >> Type C-x 1 om het hulpvenster weg te gooien. * CONCLUSIE ----------- Denk eraan dat je met C-x C-c gebruikt om Emacs te verlaten. Om tijdelijk een shell te krijgen en daarna weer in Emacs terug te komen, type C-x. De bedoeling van deze uitleg is dat ze begrijpelijk is voor alle nieuwe Emacs gebruikers. Als je dus iets onduidelijks bent tegengekomen blijf dan niet zitten en maak jezelf geen verwijten. Klaag erover! * COPI-EREN ----------- (De engelse versie van) deze uitleg is voorafgegaan door een lange reeks van Emacs tutorials, die begon met de uitleg die Stuart Cracraft schreef voor de originele Emacs. Deze nederlandse vertaling is gemaakt door Pieter Schoenmakers <tiggr(a)ics.ele.tue.nl> op basis van de GNU Emacs 20.2 TUTORIAL. (Wat nu volgt is een vertaling naar het nederlands van de condities voor gebruik en verspreiding van deze uitleg. Deze vertaling is niet gecontroleerd door een jurist. Er kunnen derhalve geen rechten aan de vertaling worden ontleend, en de vertaling wordt gevolgd door het engelse origineel.) Deze versie van de uitleg valt onder copyright, net als GNU Emacs. Je mag deze uitleg distribu-eren onder bepaalde condities: Copyright (c) 1985, 1996, 1997 Free Software Foundation Iedereen mag letterlijke copi-en van dit document, zoals ontvangen, verspreiden, op elke medium, vooropgesteld dat de copyrightmelding en toestemmingsmelding niet aangetast worden en dat de verspreider aan de ontvanger dezelfde distributierechten verleend als aan hem verleend door deze melding. Toestemming wordt verleend om gemodificeerde versies van dit document, of delen daarvan, te verspreiden, onder bovenstaande condities, vooropgesteld dat ze ook duidelijk melding maken van degene die als laatste modificaties doorgevoerd heeft. De condities voor het copi-eren van Emacs zelf zijn complexer dan dit, maar gebaseerd op dezelfde gedachte. Lees het bestand COPYING en geef vervolgens copi-en van Emacs aan al je vrienden. Help bij het uitroeien van softwarebeschermingspolitiek (`software eigendom') door vrije software te gebruiken, schrijven en delen! (Engels origineel van de copyrightmelding en condities: This version of the tutorial, like GNU Emacs, is copyrighted, and comes with permission to distribute copies on certain conditions: Copyright (c) 1985, 1996 Free Software Foundation Permission is granted to anyone to make or distribute verbatim copies of this document as received, in any medium, provided that the copyright notice and permission notice are preserved, and that the distributor grants the recipient permission for further redistribution as permitted by this notice. Permission is granted to distribute modified versions of this document, or of portions of it, under the above conditions, provided also that they carry prominent notices stating who last altered them. The conditions for copying Emacs itself are more complex, but in the same spirit. Please read the file COPYING and then do give copies of GNU Emacs to your friends. Help stamp out software obstructionism ("ownership") by using, writing, and sharing free software!) Copyright (c) 1985 Free Software Foundation, Inc; podmienky pozri na konci. Do èe¹tiny prelo¾il Milan Zamazal <pdm(a)zamazal.org>. Do slovenèiny prelo¾il Miroslav Va¹ko <vasko(a)debian.cz> Máte pred sebou tútorial k Emacsu. Príkazy Emacsu v¹eobecne vyu¾ívajú klávesu CONTROL (obèas oznaèovanú ako CTRL alebo CTL) alebo klávesu META (obèas oznaèovanú EDIT alebo ALT). Aby sme tieto názvy nemuseli stále písa» v plnom znení, budeme pou¾íva» nasledujúce skratky: C-<chr> znamená podr¾a» klávesu CONTROL a stlaèi» znak <chr>. Teda C-f znamená: podr¾te klávesu CONTROL a stlaète f. M-<chr> znamená podr¾a» klávesu META, EDIT alebo ALT a stlaèi» <chr>. Ak nemáte ¾iadnu z kláves META, EDIT ani ALT, tak namiesto toho stlaète a pustite klávesu ESC a potom <chr>. Klávesu ESC budeme oznaèova» <ESC>. Dôle¾itá poznámka: prácu s Emacsom ukonèíte stlaèením C-x C-c (dva znaky). Znaky ">>" na µavom okraji oznaèujú miesta, kde si máte vyskú¹a» príkaz. Napríklad: <<Blank lines inserted here by startup of help-with-tutorial>> >> Teraz stlaète C-v (view next screen) pre posun na ïal¹iu obrazovku. (Smelo do toho, spravte to pridr¾aním klávesy control a stlaèením v.) Od tejto chvíle by ste toto mali robi» ak doèítate zobrazenú obrazovku. V¹imnite si, ¾e pri posuve obrazoviek v¾dy zostávajú zobrazené dva riadky z predchádzajúcej obrazovky; to poskytuje urèitú náväznos» pri postupnom èítaní textu. Prvá vec, ktorú potrebujete vedie» je, ako sa v textu pohybova» z jedného miesta na druhé. U¾ viete, ako sa posunú» o jednu obrazovku vpred, pomocou C-v. Na prechod o obrazovku spä» pou¾ite M-v (podr¾te klávesu META a stlaète v alebo stlaète <ESC>v ak nemáte klávesy META, EDIT ani ALT). >> Skúste stlaèi» M-v a potom C-v, niekoµko krát to zopakujte. * ZHRNUTIE ---------- Na prezeranie obrazovkových stránok sú u¾itoèné nasledujúce príkazy: C-v posuv o obrazovku vpred M-v Posuv o obrazovku spä» C-l Zmazanie obrazovky a znovuzobrazenie celého textu, pritom sa text pod kurzorom presunie k stredu obrazovky. (Ide o control-L a nie control-1.) >> Nájdite kurzor a zapamätajte si, aký je okolo neho text. Potom stlaète C-l. Nájdite kurzor znovu a v¹imnite si, ¾e je okolo neho ten istý text. * ZÁKLADNÉ OVLÁDANIE KURZORU ---------------------------- Pohyb medzi obrazovkami je u¾itoèný, ale ako sa premiestnime na konkrétne miesto v texte na obrazovke? Je to mo¾né dosiahnu» niekoµkými spôsobmi. Najzákladnej¹ím spôsobom je pou¾itie príkazov C-p, C-b, C-f a C-n. Ka¾dý z týchto príkazov presunie kurzor na obrazovke o jeden riadok alebo ståpec v danom smere. Tu je tabuµka znázoròujúca smer posunu kurzoru vyvolaný týmito ¹tyrmi príkazmi: Predchádzajúci riadok, C-p : : Dozadu, C-b .... Momentálna pozícia kurzoru .... Dopredu, C-f : : Nasledujúci riadok, C-n >> Presuòte kurzor na prostredný riadok tohto diagramu pomocou C-n alebo C-p. Potom stlaète C-l, aby ste na obrazovke videli celý diagram vycentrovaný. Pravdepodobne si tieto príkazy µahko zapamätáte podµa zaèiatoèných písmen anglických názvov: P ako previous (predchádzajúci), N ako next (nasledujúci), B ako backward (spä»), F ako forward (vpred). Sú to základné príkazy pre pohyb kurzoru a budete ich pou¾íva» stále, tak¾e by bolo veµmi vhodné, keby ste sa ich teraz nauèili. >> Stlaète niekoµko krát C-n, aby ste kurzor presunuli na tento riadok. >> Posuòte kurzor dovnútra riadku pomocou niekoµkých C-f a potom hore stlaèením C-p. Pozorujte, èo C-p robí, keï je kurzor uprostred riadku. Ka¾dý riadok textu konèí znakom nového riadku, ktorý ho oddeµuje od nasledujúceho riadku. Znakom nového riadku by mal by» ukonèený aj posledný riadok súboru (napriek tomu, ¾e to Emacs nevy¾aduje). >> Vyskú¹ajte C-b na zaèiatku riadku. Kurzor by sa mal presunú» na koniec predchádzajúceho riadku, preto¾e ho tým presuniete cez znak nového riadku. C-f funguje analogicky ako C-b, tj. na konci riadku dôjde k presunu na ïal¹í riadok. >> Stlaète niekoµkokrát C-b, tak¾e uvidíte, kde sa nachádza kurzor. Potom stláèajte C-f, aby ste sa vrátili na koniec riadku. Potom stlaète e¹te raz C-f, aby ste sa presunuli na nasledujúci riadok. Keï kurzorom prejdete cez horný alebo dolný okraj obrazovky, posunie sa text za príslu¹ným okrajom na obrazovku. Táto vlastnos» sa nazýva "scrollovanie". Umo¾òuje premiestni» kurzor na µubovoµné miesto v texte, bez toho, aby kurzor opustil obrazovku. >> Skúste posunú» kurzor pod dolný okraj obrazovky pomocou C-n a pozorujte, èo sa stane. Ak je posun po znakoch príli¹ pomalý, mô¾ete sa pohybova» po slovách. M-f (Meta-f) robí posun o slovo vpred a M-b robí posun o slovo spä». >> Stlaète niekoµko krát M-f a M-b. Ak sa kurzor nachádza uprostred slova, M-f presunie kurzor na koniec tohto slova. Ak sa nachádza kurzor v medzere medzi slovami, M-f presunie kurzor na koniec nasledujúceho slova. M-b pracuje analogicky v opaènom smere. >> Stlaète niekoµko krát M-f a M-b spolu s C-f a C-b, aby ste videli výsledky príkazov M-f a M-b vykonávaných z rôznych miest vnútri slov a medzi nimi. V¹imnite si analógie medzi C-f a C-b na jednej strane a M-f a M-b na strane druhej. Meta znaky sú veµmi èasto vyu¾ívané pre operácie vz»ahujúce sa na entity definované jazykom (slová, vety, odstavce), naopak Control znaky pracujú na základných prvkoch nezávislých na tom, èo práve editujete (znaky, riadky, a pod.). Táto analógia platí tie¾ pre riadky a vety: C-a a C-e vykonáva presun na zaèiatok a koniec riadku, M-a a M-e vykonáva presun na zaèiatok a koniec vety. >> Skúste niekoµko krát C-a a potom niekoµko krát C-e. Skúste niekoµko krát M-a a potom niekoµko krát M-e. V¹imnite si, ¾e opakované C-a nerobí niè, ale opakované M-a v¾dy vykoná presun na ïal¹iu vetu. Princípu analógie to síce príli¹ nezodpovedá, ale napriek tomu je toto chovanie mo¾né pova¾ova» za prirodzené. Pozícia kurzoru v texte sa tie¾ nazýva "bod" ("point"). Aby sme to parafrázovali, kurzor je vidie» na obrazovke v mieste, kde je bod umiestnený v texte. Tu je prehµad jednoduchých operácií pre pohyb kurzoru vrátane príkazov pre pohyb medzi slovami a vetami: C-f Presun o znak vpred C-b Presun o znak spä» M-f Presun o slovo vpred M-b Presun o slovo spä» C-n Presun na nasledujúci riadok C-p Presun na predchádzajúci riadok C-a Presun na zaèiatok riadku C-e Presun na koniec riadku M-a Presun spä» na zaèiatok vety M-e Presun vpred na koniec vety >> Vyskú¹ajte si teraz niekoµko krát v¹etky tieto príkazy kvôli cviku. Sú to najpou¾ívanej¹ie príkazy. Ïal¹ie dva dôle¾ité príkazy pre pohyb kurzoru sú M-< (Meta men¹ie-ako), ktorý vykoná presun na zaèiatok celého textu, a M-> (Meta väè¹í-ako), ktorý vykoná presun na koniec celého textu. Na väè¹ine terminálov je "<" nad èiarkou, tak¾e pre vyvolanie tohto znaku musíte pou¾i» klávesu Shift. Na týchto termináloch je teda nutné pou¾i» klávesu Shift aj v prípade príkazu M-<; bez klávesy Shift by ste stlaèili M-èiarka. >> Skúste teraz M-< pre presun na zaèiatok tútorialu. Pou¾ite potom opakovane C-v, aby ste sa opä» vrátili sem. >> Skúste teraz M-> pre presun na koniec tútorialu. Pou¾ite potom opakovane M-v, aby ste sa opä» vrátili sem. Kurzor mô¾ete presúva» tie¾ pomocou kurzorových kláves (klávesy so ¹ípkami), ak ich Vá¹ terminál má. My Vám v¹ak doporuèujeme nauèi» sa C-b, C-f, C-n a C-p, a to z troch dôvodov. Za prvé, tieto klávesy fungujú na v¹etkých typoch terminálov. Za druhé, akonáhle raz získate cvik v pou¾ívaní Emacsu, zistíte, ¾e pou¾ívánie týchto CTRL znakov je rýchlej¹ie ako pou¾ívanie kurzorových kláves (preto¾e nemusíte presúva» ruku z písacej pozície). Za tretie, ak si zvyknete pou¾íva» tieto CTRL-znak príkazy, µahko sa nauèíte pou¾íva» iné pokroèilé príkazy pre pohyb kurzoru. Väè¹ina príkazov Emacsu akceptuje numerický argument; ten pre väè¹inu príkazov slú¾i ako opakovaè. Poèet opakovaní príkazu zadáte prostredníctvom stlaèenia C-u nasledovaného stlaèením príslu¹ných èíslic pred vyvolaním príkazu. Ak máte META (alebo EDIT èi ALT) klávesu, existuje alternatívna mo¾nos» zadania numerického argumentu: pridr¾te klávesu META a stlaète príslu¹né èíslice. Doporuèujeme nauèi» sa C-u metódu, preto¾e tá funguje na akomkoµvek terminále. Napríklad C-u 8 C-f vykoná presun o osem znakov vpred. Väè¹ina príkazov pou¾íva numerický argument ako opakovaè. Isté výnimoèné príkazy ho pou¾ívajú iným spôsobom. Medzi tieto výnimky patrí C-v a M-v. Ak dostanú numerický argument, posunú obrazovku hore alebo dole o zodpovedajúci poèet riadkov namiesto obrazoviek. Napríklad C-u 4 C-v posunie obrazovku o 4 riadky. >> Skúste teraz stlaèi» C-u 8 C-v. To by malo posunú» obrazovku o 8 riadkov hore. Pokiaµ by ste ju chceli posunú» naspä» dole, mô¾ete da» argument príkazu M-v. Ak pou¾ívate X Windows, mali by ste ma» na µavej strane emacsového okna vysokú obdå¾nikovú oblas», nazvanú scrollbar. Mô¾ete potom text posúva» klikaním my¹ou na scrollbar. >> Skúste stlaèi» prostredné tlaèítko na vrchole zvýraznenej oblasti vo vnútri scrollbaru. To by malo text posunú» na pozíciu danú tým, ako vysoko alebo nízko ste klikli. >> Skúste pri stlaèenom prostrednom tlaèidle posúva» my¹ou hore a dole. Uvidíte, ako sa text posúva hore a dole podµa toho, ako hýbete my¹ou. * KEÏ EMACS NEREAGUJE --------------------- Ak Emacs prestane reagova» na Va¹e príkazy, mô¾ete prebiehajúcu èinnos» bezpeène zastavi» pomocou C-g. Pomocou C-g mô¾ete zastavi» príkaz, ktorého èinnos» trvá príli¹ dlho. C-g mô¾ete pou¾i» tie¾ pre odstránenie numerického argumentu príkazu, ktorý nechcete dokonèi». >> Stlaète C-u 100 pre vytvorenie numerického argumentu 100 a potom stlaète C-g. Teraz stlaète C-f. Kurzor by sa mal posunú» iba o jeden znak, preto¾e ste argument zru¹ili prostredníctvom C-g. Ak ste omylom stlaèili <ESC>, mô¾ete sa ho zbavi» pomocou C-g. * DEAKTIVOVANÉ PRÍKAZY ---------------------- Niektoré príkazy Emacsu sú "deaktivované" ("disabled"), aby ich zaèínajúci pou¾ívatelia nemohli vyvola» náhodne. Ak vyvoláte niektorý z deaktivovaných príkazov, Emacs zobrazí hlásenie oznamujúce, ktorý príkaz to bol, s otázkou, èi chcete tento príkaz vykona». Ak naozaj chcete príkaz vyskú¹a», stlaète medzerník ako odpoveï na túto otázku. Zvyèajne, ak nechcete deaktivovaný príkaz vykona», odpovedzte na túto otázku pomocou "n". >> Stlaète <ESC> : (èo je deaktivovaný príkaz), potom na otázku odpovedzte n. * OKNÁ ------ Emacs mô¾e ma» niekoµko okien (windows), pritom ka¾dé z nich zobrazuje svoj vlastný text. Ako viac okien pou¾íva», objasníme neskôr. Teraz chceme objasni», ako sa zbavi» nadbytoèných okien a vráti» sa do základnej jednookennej editácie. Je to jednoduché: C-x 1 Jedno okno (tj. zru¹enie v¹etkých ostatných okien) Teda vlo¾enie Control-x nasledované èíslicou 1. C-x 1 roz¹íri okno obsahujúce kurzor cez celú obrazovku. Zru¹í to v¹etky ostatné okná. >> Stlaète Control-h k Control-f. Pozorujte, ako sa aktuálne okno zmen¹í a objaví sa nové okno kvôli zobrazeniu dokumentácie pre príkaz Control-f. >> Stlaète C-x 1 a pozorujte, ako okno s dokumentáciou zmizne. * VKLADANIE A MAZANIE --------------------- Ak chcete vlo¾i» text, proste ho napí¹te. Znaky, ktoré vidíte, ako A, 7, *, atï., sú Emacsom chápané ako text a vkladané okam¾ite. Pre vlo¾enie znaku nového riadku stlaète <Return> (klávesu Enter). Posledný znak, ktorý ste napísali, mô¾ete zmaza» stlaèením <Delete>. <Delete> je klávesa, ktorá mô¾e by» na klávesnici oznaèená "Del". V niektorých prípadoch ako <Delete> slú¾i klávesa "Backspace", av¹ak nie v¾dy! V¹eobecnej¹ie, <Delete> ma¾e znak bezprostredne pred momentálnou pozíciou kurzoru. >> Vykonajte to teraz -- napí¹te niekoµko znakov a potom ich zma¾te niekoµkými stlaèeniami <Delete>. Nebojte sa zmien v tomto súbore; originálny tútorial sa nezmení. Toto je Va¹a osobná kópia. Keï sa riadok textu zväè¹í natoµko, ¾e presiahne jeden riadok obrazovky, je zobrazený na viacerých riadkoch obrazovky. Riadok textu, ktorý pokraèuje na ïal¹om riadku obrazovky, je indikovaný spätným lomítkom ("\") na pravom okraji obrazovky. >> Vkladajte text, pokiaµ nedosiahnete pravého okraju, a pokraèujte vo vkladaní. Objaví sa Vám pokraèovací riadok. >> Pou¾ite <Delete> pre zmazanie textu, pokiaµ se riadok textu opä» nevojde na jeden riadok obrazovky. Pokraèovací riadok zmizne. Znak nového riadku mô¾ete zmaza» ako ktorýkoµvek iný znak. Zmazanie znaku nového riadku medzi dvoma riadkami spôsobí ich spojenie do jediného riadku. Ak je výsledný riadok príli¹ dlhý na to, aby sa vo¹iel na ¹írku obrazovky, bude zobrazený pokraèovacím riadkom. >> Presuòte kurzor na zaèiatok riadku a stlaète <Delete>. To tento riadok spojí s riadkom predchádzajúcim. >> Stlaète <Return> pre znovuvlo¾enie zmazaného znaku nového riadku. Spomeòte si, ¾e väè¹ina príkazov Emacsu mô¾e dosta» poèet opakovaní; vrátane textových znakov. Opakovanie textových znakov ich vlo¾í niekoµko krát. >> Vyskú¹ajte si to -- stlaète C-u 8 * pre vlo¾enie ********. Teraz u¾ poznáte najzákladnej¹ie spôsoby, ako nieèo v Emacse napísa» a ako opravova» chyby. Mô¾ete ale tie¾ maza» text po slovách alebo po riadkoch. Tu je zhrnutie operácií pre mazanie textu: <Delete> Zmazanie znaku bezprostredne pred kurzorom C-d Zmazanie znaku nasledujúceho za kurzorom M-<Delete> Zru¹enie slova bezprostredne pred kurzorom M-d Zru¹enie slova nasledujúceho za kurzorom C-k Zru¹enie textu od pozície kurzoru do konca riadku M-k Zru¹enie textu do konca aktuálnej vety V¹imnite si, ¾e <Delete> a C-d, resp. M-<Delete> a M-d, roz¹irujú paralelu zaèatú C-f a M-f (pravda, <Delete> naozaj nie je control znak, ale s tým sa nebudeme trápi»). C-k a M-k sú ako C-e a M-e v zmysle vz»ahu riadkov k vetám. ¥ubovoµnú èas» buffera mô¾ete zru¹i» aj nasledujúcim spôsobom. Presuòte sa na koniec tejto èasti a stlaète C-＠ alebo C-SPC (µubovoµnú z týchto kombinácií). (SPC znamená medzerník.) Presuòte sa na druhý koniec tejto èasti a stlaète C-w. Text medzi týmito pozíciami bude zru¹ený. >> Presuòte kurzor na písmeno L na zaèiatku predchádzajúceho odstavca. >> Stlaète C-SPC. Emacs by mal zobrazi» v spodnom riadku obrazovky správu "Mark set". >> Presuòte kurzor na písmeno c v slove "koniec" na druhom riadku odstavca. >> Stlaète C-w. Text, ktorý zaèína písmenom L a konèí pred písmenom "c" bude zru¹ený. Uvedomte si, ¾e rozdiel medzi "ru¹ením" ("killing") a "mazaním" ("deleting") je ten, ¾e "zru¹ené" veci mô¾u by» vhodené spä», zatiaµ èo "zmazané" nie. V¹eobecne príkazy, ktoré mô¾u zmaza» väè¹ie mno¾stvo textu, ukladajú text, zatiaµ èo príkazy, ktoré ma¾ú jediný znak alebo iba prázdne riadky a medzery, mazaný text neukladajú. >> Presuòte kurzor na zaèiatok neprázdneho riadku. Potom stlaète C-k pre zru¹enie textu na tomto riadku. >> Stlaète C-k druhý krát. Uvidíte, ¾e to zru¹í znak nového riadku, ktorý je za týmto riadkom. V¹imnite si, ¾e jedno C-k zru¹í obsah riadku a druhé C-k zru¹í riadok samotný a posunie v¹etky ïal¹ie riadky hore. C-k spracováva numerický argument ¹peciálne: zru¹í zodpovedajúci poèet riadkov VRÁTANE ich obsahu. To u¾ nie je opakovanie. C-u 2 C-k zru¹í dva riadky a ich obsah; dvojité stlaèenie C-k by toto obvykle nespravilo. Vracanie textov spä» sa nazýva "vhadzovanie" ("yanking"). (Predstavte si opätovné vhadzovanie, vracanie spä» textu, ktorý bol odstránený.) Zmazaný text mô¾ete vhodi» buï na to isté miesto, odkiaµ bol zmazaný, alebo na iné miesto v bufferi, alebo dokonca aj do iného súboru. Text mô¾ete vhodi» aj viac krát, keï vytvárate jeho ïal¹ie kópie. Príkazom na vhadzovanie je C-y. Tento príkaz vlo¾í posledný zmazaný text na pozíciu, na ktorej sa nachádza kurzor. >> Skúste to; stlaète C-y pre vhodenie textu spä». Ak stlaèíte C-k niekoµko krát po sebe. v¹etok zmazaný text je ulo¾ený spolu tak, aby bolo mo¾né vhodi» spä» v¹etky riadky naraz. >> Stlaète niekoµko krát C-k. Teraz obnovte naposledy zru¹ený text: >> Stlaète C-y. Potom posuòte kurzor o niekoµko riadkov ni¾¹ie a stlaète C-y znovu. Teraz vidíte, ako je mo¾né kopírova» text. Èo keï máte nejaký text, ktorý by ste radi vhodili spä» a potom zru¹íte nieèo iného? C-y by vlo¾ilo posledný zru¹ený text. Ale predchádzajúci text ni je stratený. Mô¾ete ho získa» spä» pou¾itím príkazu M-y. Potom, èo spravíte C-y pre získanie posledného zru¹eného textu, stlaèenie M-y vymení tento vhodený text za predchádzajúci zru¹ený text. Ïal¹ími a ïal¹ími stlaèeniami M-y dostávate predchádzajúce a predchádzajúce zru¹ené texty. Keï dosiahnete text, ktorý hµadáte, nemusíte s ním pre jeho uchovanie niè ïal¹ieho robi». Jednoducho vhodený text ponechajte, kde je, a pokraèujte v editácii. Ak opakujete M-y dostatoène dlho, dostanete se spä» k východziemu bodu (posledne zru¹enému textu). >> Zru¹te riadok, presuòte kurzor niekam inam a zru¹te iný riadok. Potom vykonajte C-y pre vrátenie druhého zru¹eného riadku. Potom stlaète M-y a vhodený riadok bude nahradený prvým zru¹eným riadkom. Opakujte M-y a pozorujte, èo dostávate. Pokraèujte v tom, pokiaµ sa znova neobjaví druhý zru¹ený riadok a potom niekoµko ïal¹ích. Ak chcete, mô¾ete skúsi» preda» M-y kladné a záporné argumenty. * UNDO ------ Ak vykonáte v texte zmenu a potom zistíte, ¾e to bol omyl, mô¾ete zmenu vráti» príkazom undo, C-x u. C-x u obvykle vráti zmeny vykonané jedným príkazom; pokiaµ C-x u zopakujete niekoµko krát po sebe, ka¾dé opakovanie vráti jeden ïal¹í príkaz. Sú ale dve výnimky: príkazy, ktoré nemenia text, sa nepoèítajú (to zahàòa príkazy pre pohyb kurzoru a rolovanie) a znaky vkladajúce samy seba sú obvykle spracovávané v skupinách a¾ po 20. (To je kvôli tomu, aby sa zredukoval poèet C-x u nutných pre vrátenie vkladaného textu.) >> Zru¹te tento riadok pomocou C-k, stlaète potom C-x u a riadok by sa mal znova objavi». Alternatívny undo príkaz je C-_; pracuje rovnako ako C-x u, je v¹ak menej pracné ho aplikova» niekoµko krát za sebou. Nevýhodou C-_ je, ¾e na niektorých klávesniciach nie je jasné, ako ho vyvola». To je dôvod, preèo ponúkame aj C-x u. Na niektorých termináloch mô¾ete C-_ vyvola» stlaèením / pri stlaèenom CTRL. Numerický argument pre C-_ a C-x u funguje ako poèet opakovaní. Pomocou príkazu undo mô¾ete vráti» zru¹ený aj zmazaný text. Rozdiel medzi mazaním a ru¹ením textu ovplyvòuje mo¾nos» vhodenia tohto textu pomocou C-y, neovplyvòuje ale mo¾nosti príkazu undo. * SÚBORY -------- Aby text, ktorý editujete, zostal trvale uchovaný, musíte ho ulo¾i» do súboru. Inak by bol po ukonèení Emacsu stratený. Svoju editáciu spojíte so súborom "vyhµadaním" ("finding") súboru. (Tie¾ sa to nazýva "nav¹tívenie" ("visiting") súboru.) Vyhµadanie súboru znamená, ¾e vidíte jeho obsah v Emacse. V mnohých ohµadoch je to, ako by ste editovali priamo ten súbor. Napriek tomu zmeny, ktoré prostredníctvom Emacsu robíte, sa nestanú trvalými, pokiaµ tieto zmeny do súboru "neulo¾íte" ("save"). Tým sa zamedzí nechcenému ponechaniu èiastoène zmeneného súboru v systéme. Dokonca aj keï súbor ulo¾íte, Emacs uchová pôvodný súbor pod zmeneným názvom pre prípad, ¾e by ste zistili, ¾e va¹e úpravy boli chybné. Keï sa pozriete do dolnej èasti obrazovky, uvidíte riadok, ktorý zaèína a konèí pomlèkami a na zaèiatku má "2J:-- TUTORIAL.sk" alebo nieèo podobného. Táto èas» obrazovky obvykle obsahuje meno súboru, ktorý je práve nav¹tívený. Akurát teraz máte nav¹tívený súbor nazvaný "TUTORIAL.sk", ktorý je Va¹ou osobnou èmáraciou kópiou tútorialu Emacsu. Keï v Emacse vyhµadáte súbor, jeho meno sa objaví presne na tom mieste. Príkazy pre vyhµadávanie a ukladanie súborov sa na rozdiel od ostatných príkazov, ktoré ste sa zatiaµ nauèili, skladajú z dvoch znakov. Oba zaèínajú znakom Control-x. Existuje celá sada príkazov zaèínajúcich na Control-x; veµa z nich pracuje so súbormi, buffermi a podobnými vecami. Tieto príkazy sú dlhé dva, tri alebo ¹tyri znaky. Ïal¹ou vecou súvisiacou s príkazom pre vyhµadanie súboru je to, ¾e musíte poveda», ktoré meno súboru chcete. Hovoríme, ¾e príkaz "èíta argument z terminálu" (v tomto prípade je argumentom meno súboru). Potom, èo vyvoláte príkaz C-x C-f Vyhµadanie súboru Emacs sa Vás opýta na meno súboru. Meno súboru, ktoré pí¹ete, sa objavuje v spodnom riadku obrazovky, ktorý sa v tejto situácii nazýva minibuffer. Pre editáciu mena súboru mô¾ete pou¾íva» obvyklé editaèné príkazy Emacsu. Zadávanie mena súboru (v¹eobecne akýkoµvek vstup z minibuffera) mô¾ete zru¹i» príkazom C-g. >> Stlaète C-x C-f a potom C-g. To minibuffer zru¹í a tie¾ to zru¹í príkaz C-x C-f, ktorý minibuffer pou¾il. Tak¾e nevyhµadáte ¾iadny súbor. Po napísaní mena súboru stlaète <Return>. Príkaz C-x C-f potom zaène pracova» a vyhµadá súbor, ktorý ste zvolili. Po skonèení príkazu C-x C-f minibuffer zmizne. Po malej chvílke sa obsah súboru objaví na obrazovke a mô¾ete ho editova». Keï chcete zmeny natrvalo ulo¾i», pou¾ite príkaz C-x C-s Ulo¾enie súboru To skopíruje text z Emacsu do súboru. Keï to spravíte prvý krát, Emacs premenuje pôvodný súbor na súbor s novým menom, aby nebol stratený. Nové meno je vytvorené pridaním "~" na koniec pôvodného mena súboru. Keï je ukladanie dokonèené, Emacs zobrazí meno zapísaného súboru. Mali by ste uklada» rozumne èasto, aby ste nestratili príli¹ veµa práce v prípade pádu systému. >> Stlaète C-x C-s pre ulo¾enie Va¹ej kópie tútorialu. Malo by to zobrazi» "Wrote ...TUTORIAL.sk" v spodnom riadku obrazovky. POZNÁMKA: Na niektorých systémoch spôsobí stlaèenie C-x C-s zatuhnutie obrazovky a nevidíte ¾iadny ïal¹í výstup z Emacsu. To znamená, ¾e "vlastnos»" operaèného systému nazvaná "flow control" zachytáva C-s a nepustí ho k Emacsu. Pre odtuhnutie obrazovky stlaète C-q. Potom v sekcii "Spontaneous Entry to Incremental Search" v manuále Emacsu vyhµadajte radu, ako sa vysporiada» s touto "vlastnos»ou". Existujúci súbor mô¾ete vyhµada», aby ste ho mohli prehliada» alebo editova». Mô¾ete tie¾ vyhµada» súbor, ktorý e¹te neexistuje. To je spôsob, akým sa dá vytvori» súbor v Emacse: vyhµadajte súbor, ktorý bude na zaèiatku prázdny a potom zaènite vklada» text urèený pre tento súbor. Keï po¾iadate o ulo¾enie, Emacs skutoène vytvorí súbor s textom, ktorý ste vlo¾ili. Od tej chvíle sa potom mô¾ete cíti», ako keby ste editovali u¾ existujúci súbor. * BUFFERY --------- Ak vyhµadáte pomocou C-x C-f druhý súbor, prvý súbor v Emacse zostáva. Mô¾ete sa doò spä» prepnú» jeho opätovným vyhµadaním pomocou C-x C-f. Týmto spôsobom mô¾ete do Emacsu dosta» pomerne veµa súborov. >> Vytvorte súbor pomenovaný "foo" stlaèením C-x C-f foo <Return>. Potom vlo¾te nejaký text, zmeòte ho a ulo¾te "foo" stlaèením C-x C-s. Nakoniec stlaète C-x C-f TUTORIAL.sk <Return>, èím sa vrátite spä» do tútorialu. Emacs ukladá text ka¾dého súboru do objektu nazývaného "buffer". Vyhµadanie súboru vytvorí v Emacse nový buffer. Ak chcete vidie» zoznam bufferov, ktoré momentálne existujú vo Va¹om procese Emacs, stlaète: C-x C-b Zoznam bufferov >> Skúste teraz C-x C-b. Uvidíte, ¾e ka¾dý buffer má v zozname meno a mô¾e tam ma» tie¾ meno súboru, ktorého text obsahuje. Niektoré buffery nezodpovedajú súborom. Napríklad buffer pomenovaný "*Buffer List*" nemá ¾iadny súbor. Je to buffer, ktorý obsahuje zoznam bufferov vytvorený pomocou C-x C-b. AKÝKO¥VEK text, ktorý vidíte v emacsovom okne, je v¾dy súèas»ou nejakého bufferu. >> Stlaète C-x 1, aby ste sa zbavili zoznamu bufferov. Ak zmeníte text jedného súboru a potom vyhµadáte iný súbor, nespôsobí to ulo¾enie prvého súboru. Jeho zmeny zostávajú v Emacse uchované v jemu zodpovedajúcom buffere. Vytvorenie a úprava druhého súboru nemá ¾iadny vplyv na buffer prvého súboru. To je veµmi u¾itoèné, ale tie¾ to znamená, ¾e potrebujete vhodný spôsob, ako ulo¾i» buffer prvého súboru. Nutnos» prepnú» sa spä» pomocou C-x C-f, aby ho bolo mo¾né ulo¾i» prostredníctvom C-x C-s, by bola nemiestne ob»a¾ujúca. Tak¾e máme C-x s Ulo¾enie niektorých bufferov C-x s sa Vás spýta na ka¾dý buffer, ktorý obsahuje zmeny, ktoré ste neulo¾ili. Pre ka¾dý taký buffer sa Vás spýta, èi ho má ulo¾i». >> Vlo¾te riadok textu a potom stlaète C-x s. Emacs by sa Vás mal opýta», èi má by» ulo¾ený buffer nazvaný TUTORIAL.sk. Odpovedzte na túto otázku áno (yes) stlaèením "y". * ROZ©IROVANIE SADY PRÍKAZOV ---------------------------- Existuje omnoho, omnoho viac príkazov Emacsu, ako tie, ktoré by vôbec mohli by» rozmiestnené na v¹etky control a meta znaky. Emacs tento problém obchádza prostredníctvom X (eXtend) príkazu. Ten vzniká dvoma spôsobmi: C-x Znakový eXtend. Nasledovaný jedným znakom. M-x Pomenovaný príkaz eXtend. Nasledovaný dlhým názvom. To sú príkazy, ktoré sú v¹eobecne u¾itoèné, ale menej èasto pou¾ívané ako tie, ktoré ste sa u¾ nauèili. U¾ ste videli dva z nich: súborové príkazy C-x C-f pre vyhµadanie a C-x C-s pre ulo¾enie. Iný príklad je príkaz pre ukonèenie Emacsu -- tj. príkaz C-x C-c. (Nemajte obavy o stratu zmien, ktoré ste spravili; C-x C-c ponúkne ulo¾enie ka¾dého zmeneného súboru pred tým, ne¾ sa Emacs skonèí.) C-z je príkaz na *doèasné* opustenie Emacsu -- mô¾ete sa po òom do spusteného Emacsu vráti». Na systémoch, ktoré to umo¾òujú, C-z Emacs "pozastaví"; tzn. vráti Vás do shellu, ale Emacs neskonèí. V najbe¾nej¹ích shelloch sa mô¾ete do Emacsu vráti» príkazom `fg' alebo pomocou `%emacs'. Na systémoch, ktoré pozastavovanie procesov nemajú implementované, C-z vytvorí subshell be¾iaci pod Emacsom, aby Vám dal ¹ancu spusti» iné programy a potom sa do Emacsu vráti»; nevykoná teda pravé opustenie Emacsu. V tom prípade je obvyklou cestou návratu zo subshellu do Emacsu shellový príkaz `exit'. Chvíle pre pou¾itie C-x C-c nastane, keï sa chystáte odhlási» sa zo systému. Správne je to tie¾ pri ukonèovaní Emacsu vyvolaného po¹tovým programom a rôznymi inými utilitami, preto¾e tie nemusia vedie», ako si poradi» s pozastavením Emacsu. Napriek tomu za normálnych okolností, pokiaµ sa nechystáte odhlási», je lep¹ie Emacs pozastavi» pomocou C-z ako ho ukonèi». Existuje mnoho C-x príkazov. Tu je zoznam tých, ktoré ste sa u¾ nauèili: C-x C-f Vyhµadanie súboru C-x C-s Ulo¾enie súboru C-x C-b Zoznam bufferov C-x C-c Ukonèenie Emacsu C-x u Undo Pomenované eXtended príkazy sú príkazy, ktoré sú pou¾ívané e¹te menej, alebo príkazy, ktoré sú pou¾ívané iba v istých módoch. Príkladom je príkaz replace-string, ktorý globálne nahradí jeden re»azec iným. Keï stlaèíte M-x, vypí¹e sa na spodnom riadku obrazovky prompt M-x a vy by ste mali zada» meno príkazu; v tomto prípade "replace-string". Jednoducho napí¹te "repl s<TAB>" a Emacs názov doplní. Skonèite zadávanie mena príkazu pomocou <Return>. Príkaz replace-string vy¾aduje dva argumenty -- re»azec, ktorý má by» nahradený, a re»azec, ktorý ho má nahradi». Ka¾dý argument musíte ukonèi» pomocou <Return>. >> Presuòte kurzor na prázdny riadok dva riadky pod týmto. Potom napí¹te M-x repl s<Return>zmenil<Return>modifikoval<Return>. V¹imnite si, ako sa tento riadok zmenil: nahradili ste slovo z-m-e-n-i-l slovom "modifikoval", kdekoµvek sa za aktuálnou pozíciou kurzoru vyskytlo. * AUTOMATICKÉ UKLADANIE ----------------------- Ak ste spravili zmeny v súbore, ale nemáte ich e¹te ulo¾ené, mô¾u by» v prípade páde systému stratené. Aby vás Emacs pred tým ochránil, periodicky zapisuje "auto save" súbor pre ka¾dý súbor, ktorý editujete. Meno auto save súboru má na zaèiatku a na konci #; napríklad ak sa Vá¹ soubor nazýva "hello.c", jeho auto save súbor sa nazýva "#hello.c#". Ak súbor ulo¾íte normálnym spôsobem, Emacs auto save súbor zma¾e. Ak nastane pád systému, mô¾ete svoje úpravy obnovi» z auto-save súboru, a to normálnym vyhµadaním súboru (toho, ktorý ste editovali, nie auto save súboru) a následným spustením M-x recover-file<return>. Na ¾iados» o potvrdenie odpovedzte zadaním yes<return> pre pokraèovanie a obnovenie auto-save dát. * ECHO OBLAS« ------------- Keï Emacs vidí, ¾e pí¹ete príkazy pomaly, ukazuje Vám ich v spodnej èasti obrazovky v oblasti nazývanej "echo oblast". Echo oblas» obsahuje dolný riadok obrazovky. * STAVOVÝ RIADOK ---------------- Riadok bezprostredne nad echo oblas»ou sa nazýva "stavový riadok" ("mode line"). Stavový riadok vraví nieèo ako: 2J:** TUTORIAL.sk (Fundamental)--L670--58%---------------- Tento riadok podáva u¾itoènú informáciu o stave Emacsu a texte, ktorý editujete. U¾ viete, èo znamená meno súboru -- je to súbor, ktorý ste vyhµadali. -NN%-- oznaèuje Va¹u aktuálnu pozíciu v texte; vraví, ¾e NN percent textu je nad horným okrajom obrazovky. Ak je zaèiatok súboru na obrazovke, je tu --Top-- a nie --00%--. Ak je koniec textu na obrazovke, je tu --Bot--. Ak sa dívate na tak malý text, ¾e sa celý vojde na obrazovku, stavový riadok vraví --All--. Hviezdièky blízko zaèiatku znamenajú, ¾e ste text zmenili. Tesne po vyhµadaní alebo ulo¾ení súboru v tejto èasti stavového riadku nie sú ¾iadne hviezdièky, iba pomlèky. Èas» stavového riadku v zátvorkách vraví, v akých editaèných módoch sa nachádzate. Implicitný mód je Fundamental, èo je ten, ktorý momentálne pou¾ívate. Je príkladom hlavného módu ("major mode"). Emacs má celý rad hlavných módov. Niektoré z nich sú urèené pre editovanie rôznych programovacích jazykov a/alebo textov ako napr. Lisp mód, Text mód, atï. V µubovoµnom okamihu je aktívny práve jeden hlavný mód a jeho meno je mo¾né nájs» v stavovom riadku na mieste, kde je teraz "Fundamental". Ka¾dý hlavný mód mení chovanie niektorých príkazov. Napríklad existujú príkazy pre vytváranie komentárov v programe, a preto¾e ka¾dý programovací jazyk má inú predstavu o tom, ako má komentár vyzera», musí ka¾dý hlavný mód vklada» komentáre inak. Ka¾dý hlavný mód je vlastne meno extended príkazu, ktorým sa do tohoto módu mô¾ete prepnú». Napríklad M-x fundamental-mode je príkaz pre prepnutie sa do Fundamental módu. Ak sa chystát meni» slovenský text, ako napríklad tento súbor, pravdepodobne by ste mali pou¾i» Text mód. >> Napí¹te M-x text-mode<Return>. Nebojte sa, ¾iadny z príkazov, ktoré ste sa nauèili, chovanie Emacsu nijako významne nezmení. Mô¾ete si ale v¹imnú», ¾e M-f a M-b teraz pracujú s apostrofmi ako so súèas»ou slova. Pred tým, vo Fundamental móde, M-f a M-b pracovali s apostrofmi ako oddeµovaèmi slov. Hlavné módy obyèajne robia men¹ie zmeny, ako bola táto: príkazy väè¹inou robia "to isté", ale v ka¾dom hlavnom móde pracujú trochu inak. Dokumentáciu k aktuálnemu hlavnému módu si mô¾ete zobrazi» stlaèením C-h m. >> Raz alebo viac krát pou¾ite C-u C-v, aby ste tento riadok dostali na vrchol obrazovky. >> Stlaète C-h m, aby ste videli, ako sa Text mód lí¹i od Fundamental módu. >> Stlaète C-x 1 pre odstránenie dokumentácie z obrazovky. Hlavné módy sa nazývajú hlavné preto, ¾e tie¾ existujú vedµaj¹ie módy (minor modes). Vedµaj¹ie módy nie sú alternatívou k hlavným módom, ale ich malé modifikácie. Ka¾dý vedµaj¹í mód mô¾e by» zapnutý alebo vypnutý sám o sebe nezávisle na v¹etkých ostatných vedµaj¹ích módoch a nezávisle na hlavnom móde. Tak¾e nemusíte pou¾íva» ¾iadny vedµaj¹í mód alebo mô¾ete pou¾íva» jeden vedµaj¹í mód alebo µubovoµnú kombináciu niekoµkých vedµaj¹ích módov. Jedným z veµmi u¾itoèných vedµaj¹ích módov, hlavne pre úpravy slovenských textov, je Auto Fill mód. Keï je tento mód zapnutý, Emacs zalomí riadok medzi dvoma slovami, kedykoµvek vkladáte text a riadok sa stane príli¹ dlhým. Auto Fill mód mô¾ete zapnú» vykonaním M-x auto-fill-mode<Return>. Ak je tento mód zapnutý, mô¾ete ho vypnú» vykonaním M-x auto-fill-mode<Return>. Ak je mód vypnutý, tento príkaz ho zapína, a ak je mód zapnutý, tak ho tento príkaz vypína. Vravíme, ¾e tento príkaz prepína ("toggles") tento mód. >> Napí¹te teïa M-x auto-fill-mode<Return>. Potom vkladajte "asdf " stále dookola tak dlho, pokiaµ neuvidíte, ako sa vkladaný riadok rozdelí na dva riadky. Do textu musíte vklada» medzery preto, ¾e Auto Fill mód zalamuje riadky iba v medzerách. Okraj je obvykle nastavený na 70 znakov, ale mô¾ete to zmeni» príkazom C-x f. Hodnotu okraju, ktorú si prajete, by ste mali preda» ako numerický argument. >> Napí¹te C-x f s argumentom 20. (C-u 2 0 C-x f). Potom napí¹te nejaký text a pozorujte, ako Emacs vypåòa riadky po 20. znakoch. Potom nastavte okraj spä» na 70 opätovným pou¾itím C-x f. Ak spravíte zmeny uprostred odstavca, Auto Fill mód ho nepreformátuje. Pre preformátovanie odstavca stlaète M-q (Meta-q) s kurzorom vnútri odstavca. >> Presuòte kurzor do predchádzajúceho odstavcu a stlaète M-q. * VYH¥ADÁVANIE -------------- Emacs vie v texte vyhµadáva» re»azce (tj. skupiny spojených znakov alebo slov) smerom vpred alebo vzad. Hµadanie re»azca je príkaz presúvajúci kurzor; presunie kurzor na najbli¾¹ie miesto, kde sa tento re»azec nachádza. Vyhµadávací príkaz Emacsu sa lí¹i od vyhµadávacích príkazov väè¹iny editorov v tom zmysle, ¾e je "inkrementálny". To znamená, ¾e vyhµadávanie sa robí u¾ v okam¾iku, keï zadávate hµadaný re»azec. Príkaz pre hµadanie vpred je C-s a pre hµadanie vzad C-r. POZOR! E¹te to neskú¹ajte. Keï stlaèíte C-s, uvidíte v echo oblasti prompt "I-search". To Vám vraví, ¾e Emacs sa nacháza v stave, ktorý sa nazýva inkrementálne hµadanie, a èaká, kým mu zadáte, èo chcete hµada». <RET> hµadanie ukonèí. >> Teraz zaènite hµadanie stlaèením C-s. POMALY, písmeno po písmene, pí¹te slovo 'kurzor'. Po ka¾dom písmene si v¹imnite, èo sa deje s kurzorom. Teraz ste vyhµadali "kurzor" prvý krát. >> Stlaète C-s znova, aby ste na¹li ïal¹í výskyt slova "kurzor". >> Teraz ¹tyri krát stlaète <Delete> a pozerajte, ako sa kurzor presúva. >> Stlaète <RET> pre ukonèenie hµadania. Videli ste, èo sa stalo? Emacs sa v inkrementálnom hµadaní pokú¹a prejs» na ïal¹í výskyt re»azca, ktorý ste dosiaµ napísali. Ak chcete prejs» na ïal¹í výskyt 'kurzor', jednoducho stlaète C-s zas. Ak u¾ ¾iadny taký výskyt nie je, Emacs pípne a povie Vám, ¾e hµadanie momentálne "zlyháva", C-g hµadanie ukonèí. POZNÁMKA: Na niektorých systémoch stlaèenie C-s spôsobí zatuhnutie obrazovky a neuvidíte ¾iadny ïal¹í výstup z Emacsu. To znamená, ¾e "vlastnos»" operaèného systému nazvaná "flow control" zachytáva C-s a nepustí ho k Emacsu. Pre odtuhnutie obrazovky stlaète C-q. Potom vyhµadajte v sekcii "Spontaneous Entry to Incremental Search" v manuále Emacsu radu, ako obís» túto "vlastnos»". Ak uprostred inkrementálneho hµadania stlaèíte <Delete>, uvidíte, ¾e posledný znak v hµadanom re»azci zmizne a hµadanie sa vracia na posledné miesto hµadania. Predpokladajme napríklad, ¾e ste napísali "c", aby ste na¹li prvý výskyt "k". Ak teraz stlaèíte "u", kurzor sa presunie na prvý výskyt "ku". Teraz stlaète <Delete>. To vyma¾e "u" z hµadaného re»azca a kurzor sa presunie spä» na prvý výskyt "k". Ak uprostred hµadania stlaèíte control alebo meta znak (s niekoµkými výnimkami -- znaky, ktoré sú ¹peciálne v hµadaní, ako C-s a C-r), hµadanie bude ukonèené. C-s zaèína hµadanie, ktoré hµadá akýkoµvek výskyt hµadaného re»azca ZA aktuálnu pozíciu kurzoru. Ak chcete nieèo hµada» v predchádzajúcom texte, stlaète namiesto C-s C-r. V¹etko, èo sme povedali o C-s, platí tie¾ o C-r okrem toho, ¾e smer hµadania je opaèný. * VIAC OKIEN ------------ Jednou z pekných vlastností Emacsu je to, ¾e mô¾e na obrazovke zobrazi» viac okien súèasne. >> Presuòte kurzor na tento riadok a stlaète C-u 0 C-l. >> Ak stlaèíte C-x 2, obrazovka sa rozdelí na dve okná. Obidve okná zobrazujú tento tútorial. Kurzor zostáva na vrchu okna. >> Stlaète C-M-v pre rolovanie spodného okna. (Ak nemáte skutoènú klávesu Meta, stlaète ESC C-v.) >> Stlaète C-x o ("o" ako "other") pre presun kurzoru do dolného okna. >> Pou¾ite C-v a M-v v spodnom okne pre jeho rolovanie. Pokraèujte v èítaní týchto in¹trukcií v hornom okne. >> Znovu stlaète C-x o pre presun kurzoru spä» do horného okna. Kurzor v hornom okne je presne na mieste, kde bol pôvodne. Mô¾ete ïalej pou¾íva» C-x o pre prepínanie medzi oknami. Ka¾dé okno má svoju vlastnú pozíciu kurzoru, ale kurzor zobrazuje iba jedno okno. V¹etky obvyklé editaèné príkazy platia pre okno, v ktorom sa nachádza kurzor. Toto okno nazývame "aktívne okno" ("selected window"). Príkaz C-M-v je veµmi u¾itoèný, ak v jednom okne editujete text a druhé okno pou¾ívate iba pre prehµad. Mô¾ete necháva» kurzor stále v okne, kde editujete, a postupova» po druhom okne pomocou C-M-v. C-M-v je príkladom CONTROL-META znaku. Ak máte skutoènú META klávesu, mô¾ete vyvola» C-M-v pridr¾aním oboch kláves CTRL a META pri stlaèení v. Nezále¾í na tom, èi stlaèíte ako prvú klávesu CTRL alebo META, preto¾e obe tieto klávesy fungujú ako modifikátory kláves, ktoré stlaèíte. Ak nemáte skutoènú META klávesu, mô¾ete namiesto nej pou¾i» ESC, na poradí zále¾í: musíte stlaèi» ESC a potom CTRL-v; CTRL-ESC v by nefungovalo. To preto, lebo ESC je samostatný znak, a nie modifikátor. >> Stlaète C-x 1 (v hornom okne), aby ste sa zbavili dolného okna. (Ak by ste C-x 1 stlaèili v dolnom okne, odstránilo by to horné okno. Chápte tento príkaz ako "ponechaj akurát jedno okno -- to, v ktorom akurát som".) Nemusíte v oboch oknách zobrazova» ten istý buffer. Ak pou¾ijete C-x C-f pre vyhµadanie súboru v jednom z okien, druhé okno sa nezmení. Mô¾ete vyhµadáva» súbory v oboch oknách nezávisle. Tu je ïal¹í spôsob, ako vyu¾i» dve okná na zobrazenie dvoch rôznych vecí: >> Stlaète C-x 4 C-f nasledované menom niektorého z Va¹ich súborov. Dokonèite to pomocou <Return>. Vidíte zadaný súbor v dolnom okne. Presunul sa tam aj kurzor. >> Stlaète C-x o pre presun spä» do horného okna a C-x 1 pre zmazanie dolného okna. * REKURZÍVNE EDITAÈNÉ ÚROVNE ---------------------------- Obèas sa dostanete do nieèoho, èo sa nazýva "rekurzívna editaèná úroveò" ("recursive editing level"). To je indikované hranatými zátvorkami v stavovom riadku obklopujúcemu zátvorky okolo mena hlavného módu. Napríklad mô¾ete vidie» [(Fundamental)] namiesto (Fundamental). Aby ste sa dostali z rekurzívnej editaènej úrovne, stlaète ESC ESC ESC. To je v¹eobecný "vyskakovací" príkaz. Mô¾ete ho pou¾i» tie¾ pre odstránenie niektorých okien a vyskoèenie z minibuffera. >> Stlaète M-x, aby ste sa dostali do minibuffera; potom stlaète ESC ESC ESC, aby ste sa z neho dostali von. Z rekurzívnej editaènej úrovne nemô¾ete vyskoèi» pomocou C-g. To preto, ¾e C-g je vyu¾ívané pre ru¹enie príkazov a argumentov VO VNÚTRI rekurzívnej editaènej vrstvy. * ZÍSKANIE ÏAL©EJ NÁPOVEDY -------------------------- V tomto tútoriale sme sa pokúsili Vám poskytnú» dostatok informácií, aby ste mohli zaèa» Emacs pou¾íva». V Emacse je toho toµko, ¾e by bolo nemo¾né to v¹etko objasni» v tomto návode. V ka¾dom prípade sa o Emacse mô¾ete nauèi» viac, preto¾e má veµa u¾itoèných vlastností. Emacs ponúka príkazy pre èítanie dokumentácie svojich príkazov. V¹etky tieto "help" príkazy zaèínajú znakom Control-h, ktorý sa nazýva "help znak". Pre pou¾itie vlastností nápovedy stlaète znak C-h a potom znak hovoriaci, aký druh nápovedy si ¾iadate. Ak ste NAOZAJ stratení, stlaète C-h ? a Emacs Vám povie, aké druhy nápovedy Vám mô¾e poskytnú». Ak ste stlaèili C-h a potom ste sa rozhodli, ¾e ¾iadnu nápovedu nechcete, jednoducho ju zru¹te stlaèením C-g. (Na niektorých poèítaèoch je význam znaku C-h zmenený. To by naozaj nemalo by» v¹eobecným nastavením pre v¹etkých pou¾ívateµov, tak¾e máte právo pos»a¾ova» sa systémovému administrátorovi. Do tej doby, ak C-h nezobrazuje hlásenie o nápovede v dolnej èasti obrazovky, skúste namiesto toho pou¾íva» klávesu F1 alebo M-x help RET.) Najzákladnej¹í príkaz nápovedy je C-h c. Stlaète C-h, znak c a klávesový príkaz; Emacs potom zobrazí veµmi struèný popis príkazu. >> Stlaète C-h c Control-p. Hlásenie by malo vyzera» asi takto C-p runs the command previous-line To vám oznamuje "meno funkcie". Mená funkcií sú pou¾ívané hlavne pre konfiguráciu a roz¹irovanie Emacsu. Ale preto¾e mená funkcií sú volené tak, aby naznaèovali, èo zodpovedajúci príkaz robí, mô¾u slú¾i» tie¾ ako veµmi struèná dokumentácia -- dostatoèná na to, aby Vám pripomenula príkazy, ktoré ste sa u¾ nauèili. Viacznakové príkazy ako C-x C-s a (ak nemáte META, EDIT ani ALT klávesu) <ESC>v sú pre C-h c povolené tie¾. Na získanie viac informácií o príkaze pou¾ite namiesto C-h c C-h k. >> Stlaète C-h k Control-p. To zobrazí dokumentáciu k funkcii a jej meno v emacsovom okne. Ak výstup preèítate, stlaète C-x 1, aby ste sa textu nápovedy zbavili. Nemusíte to robi» hneï. Mô¾ete chvíµu editova» a nazera» do textu nápovedy a a¾ potom stlaèi» C-x 1. Tu sú ïal¹ie u¾itoèné voµby C-h: C-h f Popis funkcie. Zadáváte meno funkcie. >> Skúste napísa» C-h f previous-line<Return>. To vypí¹e v¹etky informácie, ktoré Emacs má o funkcii implementujúcej príkaz C-p. Podobný príkaz C-h v zobrazí dokumentáciu premennej, ktorej hodnotu mô¾ete nastavi» pre ovplyvnenie chovania Emacsu. Meno premennej musíte zada», a¾ keï sa naò Emacs spýta. C-h a Príkazové apropos. Zadajte kµúèové slovo a Emacs vypí¹e v¹etky príkazy, ktorých meno obsahuje toto kµúèové slovo. V¹etky tieto príkazy mô¾u by» vyvolané pomocou Meta-x. Pre niektoré príkazy príkazové apropos vypí¹e tie¾ jedno alebo dvojznakové sekvencie, ktoré vykonávajú ten istý príkaz. >> Napí¹te C-h a file<Return>. To zobrazí v druhom okne zoznam v¹etkých M-x príkazov obsahujúcich "file" vo svojom názve. Znakové príkazy ako C-x C-f uvidíte vypísané vedµa zodpovedajúcich mien príkazov ako find-file. >> Stlaète C-M-v pre posun okna s nápovedou. Urobte to viac krát. >> Stlaète C-x 1 pre zmazanie okna s nápovedou. C-h i Èítanie on-line manuálov (tie¾ Info). Tento príkaz Vás prepne do ¹peciálneho buffera s názvom `*info*', v ktorom mô¾ete èíta» on-line manuály pre balíky in¹talované na va¹om systéme. Ak stlaèíte m emacs <Return>, mô¾ete si napríklad preèíta» manuál k Emacsu. Ak ste doteraz nikdy nepou¾ívali Info, stlaète ? a Emacs vám predstaví hlavné mo¾nosti módu pre Info. Ak toto predstavenie absolvujete, mali by ste pou¾íva» Info manuál Emacsu ako svoju primárnu dokumentáciu. * ZÁVER ------- Nezabudnite, Emacs ukonèíte vykonaním príkazu C-x C-c. Pre doèasný odskok do shellu, z ktorého sa do Emacsu mô¾ete opä» vráti», pou¾ite C-z. Zámerom tohto tútorialu je by» zrozumiteµný v¹etkým novým pou¾ívateµom, tak¾e ak narazíte na nieèo nejasného, tak nezúfajte a nedávajte to za vinu sebe -- s»a¾ujte sa! KOPÍROVANIE ----------- Tento tútorial vychádza z dllhej rady emacsových tútorialov zaèatej tútorialom napísaným Stuartom Cracraftom pre pôvodný Emacs. Táto verzia tútorialu je, podobne ako GNU Emacs, chránená copyrightom a je ¹írená s povolením distribuova» kópie za istých podmienok: Copyright (c) 1985, 1996 Free Software Foundation Ka¾dému je zaruèené právo vytvára» a distribuova» presné kópie tohto dokumentu tak, ako ho dostal, na akomkoµvek médiu, s tým, ¾e bude zachovaná táto poznámka o autorstve a poznámka o povolení, a ¾e distribútor zaruèuje príjemcovi právo na ïal¹iu redistribúciu povolenú touto poznámkou. Je zaruèené právo distribuova» modifikované verzie tohto dokumentu alebo jeho èastí pod hore uvedenými podmienkami za predpokladu, ¾e obsahuje jasné poznámky uvádzajúce, kto urobil posledné úpravy. Podmienky pre kopírovanie Emacsu samotného sú zlo¾itej¹ie, ale v rovnakom duchu. Preèítajte si, prosím, súbor COPYING a potom dajte kópie GNU Emacsu svojim priateµom. Pomáhajte potlaèova» softwarovú ob¹trukciu ("vlastníctvo") pou¾ívaním, písaním a zdieµaním free softwaru! ;;; Local Variables: ;;; coding: iso-latin-2 ;;; End: Copyright (c) 1985 Free Software Foundation, Inc; podmínky viz na konci. Do èe¹tiny pøelo¾il Milan Zamazal <pdm(a)zamazal.org>. Máte pøed sebou tutoriál k Emacsu. Pøíkazy Emacsu obecnì vyu¾ívají klávesu CONTROL (obèas oznaèovanou CTRL nebo CTL) nebo klávesu META (obèas oznaèovanou EDIT nebo ALT). Abychom tyto názvy nemuseli stále psát v plném znìní, budeme pou¾ívat následující zkratky: C-<chr> znamená pøidr¾et klávesu CONTROL a stisknout znak <chr>. Tedy C-f znamená: pøidr¾te klávesu CONTROL a stisknìte f. M-<chr> znamená pøidr¾et klávesu META, EDIT nebo ALT a stisknout <chr>. Pokud ¾ádnou z kláves META, EDIT ani ALT nemáte, tak místo toho stisknìte a pus»te klávesu ESC a poté <chr>. Klávesu ESC budeme znaèit <ESC>. Dùle¾itá poznámka: práci s Emacsem ukonèíte stiskem C-x C-c (dva znaky). Znaky ">>" na levém okraji znaèí místa, kde si máte vyzkou¹et pøíkaz. Napøíklad: <<Blank lines inserted here by startup of help-with-tutorial>> >> Nyní stisknìte C-v (view next screen) pro posun na dal¹í obrazovku. (Smìle do toho, proveïte to pøidr¾ením klávesy CONTROL a stiskem v.) Od této chvíle byste toto mìli provádìt kdykoliv doètete zobrazenou obrazovku. V¹imnìte si, ¾e pøi posuvu obrazovek v¾dy zùstávají zobrazeny dva øádky z pøedchozí obrazovky; to poskytuje urèitou návaznost pøi postupném ètení textu. První vìc, kterou potøebujete vìdìt, je jak se v textu pohybovat z jednoho místa na druhé. U¾ víte, jak se posunout o jednu obrazovku vpøed, pomocí C-v. K pøechodu o obrazovku zpìt pou¾ijte M-v (pøidr¾te klávesu META a stisknìte v nebo stisknìte <ESC>v, jestli¾e nemáte ¾ádnou z kláves META, EDIT nebo ALT). >> Zkuste stisknout M-v a pak C-v, nìkolikrát to zopakujte. * SHRNUTÍ --------- K prohlí¾ení obrazovkových stránek jsou u¾iteèné následující pøíkazy: C-v Posun o obrazovku vpøed M-v Posun o obrazovku zpìt C-l Smazání obrazovky a znovuzobrazení celého textu, pøitom se text pod kurzorem pøesune ke støedu obrazovky. (Jedná se o CONTROL-L a ne CONTROL-1.) >> Najdìte kurzor a zapamatujte si, jaký text je kolem nìj. Pak stisknìte C-l. Najdìte kurzor znovu a v¹imnìte si, ¾e je kolem nìj tentý¾ text. * ZÁKLADNÍ OVLÁDÁNÍ KURZORU --------------------------- Pohyb mezi obrazovkami je u¾iteèný, ale jak se pøemístíte na konkrétní místo v textu na obrazovce? Je toho mo¾no dosáhnout nìkolika zpùsoby. Nejzákladnìj¹ím zpùsobem je pou¾ití pøíkazù C-p, C-b, C-f a C-n. Ka¾dý z tìchto pøíkazù pøesune kurzor na obrazovce o jeden øádek nebo sloupec v daném smìru. Zde je tabulka znázoròující smìr posuvu kurzoru vyvolaný tìmito ètyømi pøíkazy: Pøedchozí øádek, C-p : : Dozadu, C-b .... Momentální pozice kurzoru .... Dopøedu, C-f : : Následující øádek, C-n >> Pøesuòte kurzor na prostøední øádek tohoto diagramu pomocí C-n nebo C-p. Potom stisknìte C-l, abyste na obrazovce vidìli celý diagram vycentrován. Pravdìpodobnì se vám budou tyto pøíkazy snadno pamatovat podle poèáteèních písmen anglických názvù: P jako previous (pøedchozí), N jako next (následující), B jako backward (zpìt), F jako forward (vpøed). Jsou to základní pøíkazy pro pohyb kurzoru a budete je pou¾ívat neustále, tak¾e by bylo velmi vhodné, kdybyste se je teï nauèili. >> Proveïte nìkolikrát C-n, abyste kurzor pøesunuli na tento øádek. >> Posuòte kurzor dovnitø øádku pomocí nìkolika C-f a pak nahoru stiskem C-p. Pozorujte, co C-p dìlá, kdy¾ je kurzor uprostøed øádku. Ka¾dý øádek textu konèí znakem nového øádku, který jej oddìluje od øádku následujícího. Znakem nového øádku by mìl být ukonèen i poslední øádek souboru (pøesto¾e to Emacs nevy¾aduje). >> Vyzkou¹ejte C-b na zaèátku øádku. Kurzor by se mìl pøesunout na konec pøedchozího øádku, nebo» jej tím pøesunete pøes znak nového øádku. C-f funguje analogicky jako C-b, tj. na konci øádku dojde k pøesunu na dal¹í øádek. >> Proveïte nìkolik C-b, tak¾e uvidíte, kde se nachází kurzor. Pak provádìjte C-f, abyste se vrátili na konec øádku. Pak proveïte je¹tì jednou C-f, abyste se pøesunuli na následující øádek. Kdy¾ kurzorem pøejdete pøes horní nebo dolní okraj obrazovky, posune se text za pøíslu¹ným okrajem na obrazovku. Tato vlastnost se nazývá "scrollování". Umo¾òuje pøemístit kurzor na libovolné místo v textu, ani¾ by kurzor opustil obrazovku. >> Zkuste posunout kurzor pod dolní okraj obrazovky pomocí C-n a pozorujte, co se stane. Jestli¾e je posun po znacích pøíli¹ pomalý, mù¾ete se pohybovat po slovech. M-f (META-f) provádí posun o slovo vpøed a M-b provádí posun o slovo zpìt. >> Stisknìte nìkolikrát M-f a M-b. Pokud se kurzor nachází uprostøed slova, M-f provede pøesun na konec tohoto slova. Nachází-li se kurzor v mezeøe mezi slovy, M-f provede pøesun na konec následujícího slova. M-b pracuje analogicky v opaèném smìru. >> Stisknìte nìkolikrát M-f a M-b prolo¾enì s C-f a C-b, abyste vidìli výsledky pøíkazù M-f a M-b provádìných z rùzných míst uvnitø slov a mezi nimi. V¹imnìte si analogie mezi C-f a C-b na jedné stranì a M-f a M-b na stranì druhé. Znaky s klávesou META jsou velmi èasto vyu¾ívány pro operace vztahující se k entitám definovaným jazykem (slova, vìty, odstavce), zatímco znaky s klávesou CONTROL pracují na základních prvcích nezávislých na tom, co zrovna editujete (znaky, øádky, apod.). Tato analogie platí také pro øádky a vìty: C-a a C-e provádí pøesun na zaèátek a konec øádku, M-a a M-e provádí pøesun na zaèátek a konec vìty. >> Zkuste nìkolikrát C-a a poté nìkolikrát C-e. Zkuste nìkolikrát M-a a poté nìkolikrát M-e. V¹imnìte si, ¾e opakované C-a nedìlá nic, zatímco opakované M-a v¾dy provádí posun o dal¹í vìtu. Principu analogie to sice pøíli¹ neodpovídá, ale pøesto je toto chování mo¾no pova¾ovat za pøirozené. Pozice kurzoru v textu se také nazývá "bod" ("point"). Abychom to parafrázovali, kurzor je vidìt na obrazovce v místì, kde je bod umístìn v textu. Zde je pøehled jednoduchých operací pro pohyb kurzoru vèetnì pøíkazù pro pohyb mezi slovy a vìtami: C-f Pøesun o znak vpøed C-b Pøesun o znak zpìt M-f Pøesun o slovo vpøed M-b Pøesun o slovo zpìt C-n Pøesun na následující øádek C-p Pøesun na pøedchozí øádek C-a Pøesun na zaèátek øádku C-e Pøesun na konec øádku M-a Pøesun zpìt na zaèátek vìty M-e Pøesun vpøed na konec vìty >> Vyzkou¹ejte si teï nìkolikrát v¹echny tyto pøíkazy pro procvièení. Jsou to nejpou¾ívanìj¹í pøíkazy. Dal¹í dva dùle¾ité pøíkazy pro pohyb kurzoru jsou M-< (META men¹í-ne¾), který provede pøesun na zaèátek celého textu, a M-> (META vìt¹í-ne¾), který provede pøesun na konec celého textu. Na vìt¹inì terminálù je "<" nad èárkou, tak¾e pro vyvolání tohoto znaku musíte pou¾ít klávesu Shift. Na tìchto terminálech je tedy nutno pou¾ít klávesu Shift i v pøípadì pøíkazu M-<; bez klávesy Shift byste provedli M-èárka. >> Zkuste teï M-< pro pøesun na zaèátek tutoriálu. Pou¾ijte pak opakovanì C-v, abyste se opìt vrátili sem. >> Zkuste teï M-> pro pøesun na konec tutoriálu. Pou¾ijte pak opakovanì M-v, abyste se opìt vrátili sem. Kurzor mù¾ete pøesouvat také pomocí kurzorových kláves (klávesy se ¹ipkami), pokud je vá¹ terminál má. My v¹ak doporuèujeme nauèit se C-b, C-f, C-n a C-p, a to ze tøí dùvodù. Za prvé, tyto klávesy fungují na v¹ech typech terminálù. Za druhé, jakmile jednou získáte cvik v pou¾ívání Emacsu, zjistíte, ¾e pou¾ívání tìchto CTRL znakù je rychlej¹í ne¾ pou¾ívání kurzorových kláves (proto¾e nemusíte pøesouvat ruku z psací pozice). Za tøetí, zvyknete-li si pou¾ívat tyto CTRL-znak pøíkazy, snadno se nauèíte pou¾ívat jiné pokroèilé pøíkazy pro pohyb kurzoru. Vìt¹ina pøíkazù Emacsu akceptuje numerický argument; ten pro vìt¹inu pøíkazù slou¾í jako opakovaè. Poèet opakování pøíkazu zadáte prostøednictvím stisku C-u následovaného stiskem pøíslu¹ných èíslic pøed vyvoláním pøíkazu. Máte-li META (nebo EDIT èi ALT) klávesu, existuje alternativní mo¾nost zadání numerického argumentu: pøidr¾te klávesu META a stisknìte pøíslu¹né èíslice. Doporuèujeme nauèit se C-u metodu, proto¾e ta funguje na jakémkoliv terminálu. Napøíklad C-u 8 C-f provede pøesun o osm znakù vpøed. Vìt¹ina pøíkazù pou¾ívá numerický argument jako opakovaè. Jisté výjimeèné pøíkazy jej pou¾ívají jiným zpùsobem. Mezi tyto výjimky patøí C-v a M-v. Dostanou-li numerický argument, posunou obrazovku nahoru nebo dolù o odpovídající poèet øádkù místo obrazovek. Napøíklad C-u 4 C-v posune obrazovku o 4 øádky. >> Zkuste teï stisknout C-u 8 C-v. To by mìlo posunout obrazovku o 8 øádkù nahoru. Pokud byste ji chtìli posunout zpìt dolù, mù¾ete dát argument pøíkazu M-v. Pou¾íváte-li X Window, mìli byste mít na levé stranì emacsového okna vysokou obdélníkovou oblast, nazývanou scrollbar. Mù¾ete pak text posouvat klikáním my¹í na scrollbar. >> Zkuste stisknout prostøední tlaèítko na vrcholu zvýraznìné oblasti uvnitø scrollbaru. To by mìlo text posunout na pozici danou tím, jak vysoko nebo nízko jste kliknuli. >> Zkuste pøi stisknutém prostøedním tlaèítku posouvat my¹í nahoru a dolù. Uvidíte, jak se text posouvá nahoru a dolù podle toho, jak posouváte my¹í. * KDY® EMACS NEREAGUJE ---------------------- Jestli¾e Emacs pøestane reagovat na va¹e pøíkazy, mù¾ete probíhající èinnost bezpeènì zastavit pomocí C-g. Pomocí C-g mù¾ete zastavit pøíkaz, jeho¾ provádìní trvá pøíli¹ dlouho. C-g mù¾ete pou¾ít také pro odstranìní numerického argumentu pøíkazu, který nechcete dokonèit. >> Stisknìte C-u 100 pro vytvoøení numerického argumentu 100 a pak stisknìte C-g. Nyní stisknìte C-f. Mìl by být proveden posun o právì jeden znak, proto¾e jste argument zru¹ili prostøednictvím C-g. Pokud jste omylem stiskli <ESC>, mù¾ete se jej zbavit pomocí C-g. * DEAKTIVOVANÉ PØÍKAZY ---------------------- Nìkteré pøíkazy Emacsu jsou "deaktivované" ("disabled"), aby je zaèínající u¾ivatelé nemohli vyvolat náhodnì. Pokud vyvoláte nìkterý z deaktivovaných pøíkazù, Emacs zobrazí hlá¹ení oznamující, který pøíkaz to byl, s dotazem, zda chcete tento pøíkaz provést. Pokud opravdu chcete pøíkaz vyzkou¹et, stisknìte mezerník jako odpovìï na tuto otázku. Obyèejnì, jestli¾e nechcete deaktivovaný pøíkaz provést, odpovìzte na tuto otázku pomocí "n". >> Stisknìte <ESC> : (co¾ je deaktivovaný pøíkaz), pak na otázku odpovìzte n. * OKNA ------ Emacs mù¾e mít nìkolik oken (windows), z nich¾ ka¾dé zobrazuje svùj vlastní text. Jak více oken pou¾ívat, objasníme pozdìji. Nyní chceme objasnit, jak se zbavit nadbyteèných oken a vrátit se do základní jednookenní editace. Je to jednoduché: C-x 1 Jedno okno (tj. zru¹ení v¹ech ostatních oken) Tedy vlo¾ení CONTROL-x následované èíslicí 1. C-x 1 roz¹íøí okno obsahující kurzor pøes celou obrazovku. Zru¹í to v¹echna ostatní okna. >> Stisknìte C-h k C-f. Pozorujte, jak se aktuální okno zmen¹í a objeví se nové okno za úèelem zobrazení dokumentace k pøíkazu C-f. >> Stisknìte C-x 1 a pozorujte, jak okno s dokumentací zmizí. * VKLÁDÁNÍ A MAZÁNÍ ------------------- Chcete-li vlo¾it text, prostì jej napi¹te. Znaky, které vidíte, jako A, 7, *, atd., jsou Emacsem chápány jako text a vkládány okam¾itì. Pro vlo¾ení znaku nového øádku stisknìte <Return> (klávesu Enter). Poslední znak, který jste napsali, mù¾ete smazat stiskem <Delete>. <Delete> je klávesa, která mù¾e být na klávesnici oznaèena "Del". V nìkterých pøípadech jako <Delete> slou¾í klávesa "Backspace", av¹ak ne v¾dy! Obecnìji, <Delete> ma¾e znak bezprostøednì pøed momentální pozicí kurzoru. >> Proveïte to teï -- napi¹te nìkolik znakù a pak je sma¾te nìkolika stisky <Delete>. Nebojte se zmìn v tomto souboru; originální tutoriál se nezmìní. Toto je va¹e osobní kopie. Kdy¾ se øádek textu zvìt¹í natolik, ¾e pøesáhne jeden øádek obrazovky, je zobrazen na více øádcích obrazovky. Øádek textu, který pokraèuje na dal¹ím øádku obrazovky, je indikován zpìtným lomítkem ("\") na pravém okraji obrazovky. >> Vkládejte text, a¾ dosáhnete pravého okraje, a pokraèujte ve vkládání. Objeví se vám pokraèovací øádek. >> Pou¾ijte <Delete> pro smazání textu, a¾ se øádek textu opìt vejde na jeden øádek obrazovky. Pokraèovací øádek zmizí. Znak nového øádku mù¾ete smazat jako kterýkoliv jiný znak. Smazání znaku nového øádku mezi dvìma øádky zpùsobí jejich spojení do jediného øádku. Je-li výsledný øádek pøíli¹ dlouhý na to, aby se ve¹el na ¹íøku obrazovky, bude zobrazen pokraèovacím øádkem. >> Pøesuòte kurzor na zaèátek øádku a stisknìte <Delete>. To tento øádek spojí s øádkem pøedchozím. >> Stisknìte <Return> pro znovuvlo¾ení smazaného znaku nového øádku. Vzpomeòte si, ¾e vìt¹ina pøíkazù Emacsu mù¾e dostat poèet opakování; vèetnì textových znakù. Opakování textových znakù je vlo¾í nìkolikrát. >> Vyzkou¹ejte si to teï -- stisknìte C-u 8 * pro vlo¾ení ********. Teï u¾ znáte nejzákladnìj¹í zpùsoby, jak nìco v Emacsu napsat a jak opravovat chyby. Mù¾ete ov¹em také mazat po slovech nebo po øádcích. Zde je shrnutí operací pro mazání textu: <Delete> Smazání znaku bezprostøednì pøed kurzorem C-d Smazání znaku následujícího za kurzorem M-<Delete> Zru¹ení slova bezprostøednì pøed kurzorem M-d Zru¹ení slova následujícího za kurzorem C-k Zru¹ení textu od pozice kurzoru do konce øádku M-k Zru¹ení textu do konce aktuální vìty V¹imnìte si, ¾e <Delete> a C-d, resp. M-<Delete> a M-d, roz¹iøují paralelu zapoèatou C-f a M-f (pravda, <Delete> opravdu není CONTROL znak, ale netrapme se tím). C-k a M-k jsou jako C-e a M-e ve smyslu vztahu øádkù k vìtám. Libovolnou èást bufferu mù¾ete té¾ zru¹it následující metodou. Pøesuòte se na jeden konec této èásti a stisknìte C-＠ nebo C-SPC (libovolnou z tìchto kombinací). (SPC oznaèuje mezerník.) Pøesuòte se na druhý konec této èásti a stisknìte C-w. Text mezi tìmito pozicemi bude zru¹en. >> Pøesuòte kurzor na písmeno L na zaèátku pøedchozího odstavce. >> Stisknìte C-SPC. Emacs by mìl ve spodním øádku obrazovky zobrazit zprávu "Mark set". >> Pøesuòte kurzor na písmeno c ve slovì "konec" na druhém øádku odstavce. >> Stisknìte C-w. Text zaèínající písmenem L a konèící pøed písmenem c bude zru¹en. Uvìdomte si, ¾e rozdíl mezi "ru¹ením" ("killing") a "mazáním" ("deleting") je ten, ¾e "zru¹ené" vìci mohou být zpìt vhozeny, zatímco "smazané" nikoliv. Obecnì pøíkazy, které mohou smazat vìt¹í mno¾ství textu, ukládají text, zatímco pøíkazy, které ma¾ou jediný znak nebo pouze prázdné øádky a mezery, mazaný text neukládají. >> Pøesuòte kurzor na zaèátek neprázdného øádku. Pak stisknìte C-k pro zru¹ení textu na tomto øádku. >> Stisknìte C-k podruhé. Uvidíte, ¾e to zru¹í znak nového øádku, který je za tímto øádkem. V¹imnìte si, ¾e jedno C-k zru¹í obsah øádku a druhé C-k zru¹í øádek samotný a posune v¹echny dal¹í øádky nahoru. C-k zpracovává numerický argument speciálnì: zru¹í odpovídající poèet øádkù VÈETNÌ jejich obsahu. To u¾ není opakování. C-u 2 C-k zru¹í dva øádky a jejich obsah; dvojitý stisk C-k by toto obvykle neudìlal. Vracení textu zpìt se nazývá "vhazování" ("yanking"). (Pøedstavte si opìtovné vhazování, vracení døíve odstranìného textu zpátky.) Zru¹ený text mù¾ete vhodit buï na stejné místo, kde byl zru¹en, nebo na jiné místo v bufferu, nebo dokonce i do jiného souboru. Text mù¾ete vhodit i vícekrát, vytváøíte tak jeho dal¹í kopie. Pøíkazem pro vhazování je C-y. Tento pøíkaz vlo¾í poslední smazaný text na pozici, na které se nachází kurzor. >> Zkuste to; stisknìte C-y pro vhození textu zpìt. Stisknete-li nìkolikrát C-k po sobì, v¹echen smazaný text je ulo¾en spoleènì tak, aby bylo mo¾né vhodit zpìt v¹echny øádky najednou. >> Stisknìte nìkolikrát C-k. Nyní obnovte poslednì zru¹ený text: >> Stisknìte C-y. Pak posuòte kurzor o nìkolik øádkù ní¾e a stisknìte C-y znova. Nyní vidíte, jak lze text kopírovat. Co kdy¾ máte nìjaký text, který byste rádi vhodili zpìt a pak zru¹íte nìco jiného? C-y by vlo¾ilo poslední zru¹ený text. Av¹ak pøedchozí text není ztracen. Mù¾ete jej získat zpìt pou¾itím pøíkazu M-y. Poté, co provedete C-y pro získání posledního zru¹eného textu, stisk M-y vymìní tento vhozený text za pøedchozí zru¹ený text. Dal¹ími a dal¹ími stisky M-y dostáváte pøedcházející a pøedcházející zru¹ené texty. Kdy¾ dosáhnete textu, který hledáte, nemusíte s ním pro jeho uchování nic dal¹ího provádìt. Jednodu¹e vhozený text ponechejte, kde je, a pokraèujte v editaci. Pokud opakujete M-y dostateènì dlouho, dostanete se zpátky k výchozímu bodu (poslednì zru¹enému textu). >> Zru¹te øádek, pøesuòte kurzor nìkam jinam a zru¹te jiný øádek. Pak proveïte C-y pro vrácení druhého zru¹eného øádku. Pak proveïte M-y a vhozený øádek bude nahrazen prvním zru¹eným øádkem. Opakujte M-y a pozorujte, co dostáváte. Pokraèujte v tom, dokud se znovu neobjeví druhý zru¹ený øádek a pak nìkolik dal¹ích. Chcete-li, mù¾ete zkusit pøedat M-y kladné a záporné argumenty. * UNDO ------ Jestli¾e provedete v textu zmìnu a pak zjistíte, ¾e to byl omyl, mù¾ete zmìnu vrátit pøíkazem undo, C-x u. C-x u obvykle vrátí zmìny provedené jedním pøíkazem; pokud C-x u zopakujete nìkolikrát za sebou, ka¾dé opakování vrátí jeden dal¹í pøíkaz. Jsou ale dvì výjimky: pøíkazy, které nemìní text, se nepoèítají (to zahrnuje pøíkazy pro pohyb kurzoru a scrollování) a znaky vkládající samy sebe jsou obvykle zpracovávány ve skupinách a¾ po 20. (To je kvùli tomu, aby se zredukoval poèet C-x u nutných pro vrácení vkládaného textu.) >> Zru¹te tento øádek pomocí C-k, stisknìte pak C-x u a øádek by se mìl znovu objevit. Alternativní undo pøíkaz je C-_; pracuje stejnì jako C-x u, je v¹ak ménì pracné jej aplikovat nìkolikrát za sebou. Nevýhodou C-_ je, ¾e na nìkterých klávesnicích není zøejmé, jak jej vyvolat. To je dùvod, proè nabízíme i C-x u. Na nìkterých terminálech mù¾ete C-_ vyvolat stiskem / pøi stisknutém CTRL. Numerický argument pro C-_ a C-x u funguje jako poèet opakování. Pomocí pøíkazu undo mù¾ete vrátit zru¹ený stejnì jako smazaný text. Rozdíl mezi mazáním a ru¹ením textu ovlivòuje mo¾nost vhození tohoto textu pomocí C-y, neovlivòuje mo¾nosti pøíkazu undo. * SOUBORY --------- Aby text, který editujete, zùstal trvale uchován, musíte jej ulo¾it do souboru. Jinak by byl po ukonèení Emacsu ztracen. Svoji editaci spojíte se souborem "vyhledáním" ("finding") souboru. (Také se to nazývá "nav¹tívení" ("visiting") souboru.) Vyhledání souboru znamená, ¾e vidíte jeho obsah v Emacsu. V mnoha ohledech je to, jako byste editovali pøímo ten soubor. Nicménì zmìny, které prostøednictvím Emacsu èiníte, se nestanou trvalými, dokud tyto zmìny do souboru "neulo¾íte" ("save"). Tím se zamezí nechtìnému ponechání èásteènì zmìnìného souboru v systému. Dokonce i kdy¾ soubor ulo¾íte, Emacs uchová pùvodní soubor pod zmìnìným názvem pro pøípad, ¾e byste zjistili, ¾e va¹e úpravy byly chybné. Kdy¾ se podíváte do dolní èásti obrazovky, uvidíte øádek, který zaèíná a konèí pomlèkami a na zaèátku má "2J:-- TUTORIAL.cs" nebo nìco podobného. Tato èást obrazovky obvykle obsahuje jméno souboru, který je právì nav¹tíven. Zrovna teï máte nav¹tíven soubor nazvaný "TUTORIAL.cs", který je va¹í osobní èmárací kopií tutoriálu Emacsu. Kdy¾ v Emacsu vyhledáte soubor, jeho jméno se objeví pøesnì na tom místì. Pøíkazy pro vyhledávání a ukládání souborù se na rozdíl od ostatních pøíkazù, které jste se zatím nauèili, skládají ze dvou znakù. Oba zaèínají znakem CONTROL-x. Existuje celá øada pøíkazù zaèínajících na CONTROL-x; mnoho z nich pracuje se soubory, buffery a podobnými vìcmi. Tyto pøíkazy jsou dlouhé dva, tøi nebo ètyøi znaky. Dal¹í vìcí ohlednì pøíkazu pro vyhledání souboru je to, ¾e musíte øíct, které jméno souboru chcete. Øíkáme, ¾e pøíkaz "ète argument z terminálu" (v tomto pøípadì je argumentem jméno souboru). Poté co vyvoláte pøíkaz C-x C-f Vyhledání souboru Emacs se vás zeptá na jméno souboru. Jméno souboru, které pí¹ete, se objevuje ve spodním øádku obrazovky, který se v této situaci nazývá minibuffer. Pro editaci jména souboru mù¾ete pou¾ívat obvyklé editaèní pøíkazy Emacsu. Zadávání jména souboru (obecnì kterýkoliv vstup z minibufferu) mù¾ete zru¹it pøíkazem C-g. >> Stisknìte C-x C-f a pak C-g. To minibuffer zru¹í a takté¾ to zru¹í pøíkaz C-x C-f, který minibuffer pou¾il. Tak¾e nevyhledáte ¾ádný soubor. Po napsání jména souboru stisknìte <Return>. Pøíkaz C-x C-f pak zaène pracovat a vyhledá soubor, který jste zvolili. Po skonèení pøíkazu C-x C-f minibuffer zmizí. Po malé chvilce se obsah souboru objeví na obrazovce a mù¾ete jej editovat. Kdy¾ chcete zmìny trvale ulo¾it, pou¾ijte pøíkaz C-x C-s Ulo¾ení souboru To zkopíruje text z Emacsu do souboru. Kdy¾ to provedete poprvé, Emacs pøejmenuje pùvodní soubor na soubor s novým jménem, aby nebyl ztracen. Nové jméno je vytvoøeno pøidáním "~" na konec pùvodního jména souboru. Kdy¾ je ukládání dokonèeno, Emacs zobrazí jméno zapsaného souboru. Mìli byste ukládat rozumnì èasto, abyste neztratili pøíli¹ mnoho práce v pøípadì pádu systému. >> Stisknìte C-x C-s pro ulo¾ení va¹í kopie tutoriálu. Mìlo by to zobrazit "Wrote ...TUTORIAL.cs" ve spodním øádku obrazovky. POZNÁMKA: Na nìkterých systémech zpùsobí stisk C-x C-s ztuhnutí obrazovky a nevidíte ¾ádný dal¹í výstup z Emacsu. To znamená, ¾e "vlastnost" operaèního systému zvaná "flow control" zachycuje C-s a nepropustí jej k Emacsu. Pro odtuhnutí obrazovky stisknìte C-q. Pak v sekci "Spontaneous Entry to Incremental Search" v manuálu Emacsu vyhledejte radu, jak se vypoøádat s touto "vlastností". Existující soubor mù¾ete vyhledat, abyste jej mohli prohlí¾et nebo editovat. Mù¾ete také vyhledat soubor, který je¹tì neexistuje. To je zpùsob, jakým lze vytvoøit soubor v Emacsu: vyhledejte soubor, který bude na zaèátku prázdný a pak zaènìte vkládat text urèený pro tento soubor. Kdy¾ po¾ádáte o ulo¾ení, Emacs skuteènì vytvoøí soubor s textem, který jste vlo¾ili. Od té chvíle se pak mù¾ete cítit, jako kdybyste editovali ji¾ existující soubor. * BUFFERY --------- Jestli¾e vyhledáte pomocí C-x C-f druhý soubor, první soubor v Emacsu zùstává. Mù¾ete se do nìj zpìt pøepnout jeho opìtovným vyhledáním pomocí C-x C-f. Tímto zpùsobem mù¾ete do Emacsu dostat pomìrnì hodnì souborù. >> Vytvoøte soubor pojmenovaný "foo" stiskem C-x C-f foo <Return>. Potom vlo¾te nìjaký text, zeditujte jej a ulo¾te "foo" stiskem C-x C-s. Nakonec stisknìte C-x C-f TUTORIAL.cs <Return>, èím¾ se vrátíte zpìt do tutoriálu. Emacs ukládá text ka¾dého souboru do objektu nazývaného "buffer". Vyhledání souboru vytvoøí v Emacsu nový buffer. Chcete-li vidìt seznam bufferù, které momentálnì existují ve va¹em procesu Emacs, stisknìte: C-x C-b Seznam bufferù >> Zkuste teï C-x C-b. Podívejte se, ¾e ka¾dý buffer má v seznamu jméno a mù¾e tam mít také jméno souboru, jeho¾ text obsahuje. Nìkteré buffery neodpovídají souborùm. Napøíklad buffer pojmenovaný "*Buffer List*" nemá ¾ádný soubor. Je to buffer, který obsahuje seznam bufferù vytvoøený pomocí C-x C-b. JAKÝKOLIV text, který vidíte v emacsovém oknì, je v¾dy souèástí nìjakého bufferu. >> Stisknìte C-x 1, abyste se zbavili seznamu bufferù. Pokud provedete zmìny textu jednoho souboru a pak vyhledáte jiný soubor, nezpùsobí to ulo¾ení prvního souboru. Jeho zmìny zùstávají v Emacsu uchovány v jemu odpovídajícím bufferu. Vytvoøení a editace druhého souboru nemá ¾ádný vliv na buffer prvního souboru. To je velmi u¾iteèné, ale také to znamená, ¾e potøebujete vhodný zpùsob, jak ulo¾it buffer prvního souboru. Nutnost pøepnout se zpátky pomocí C-x C-f, aby jej bylo mo¾no ulo¾it prostøednictvím C-x C-s, by byla nemístnì obtì¾ující. Tak¾e máme C-x s Ulo¾ení nìkterých bufferù C-x s se vás zeptá na ka¾dý buffer, který obsahuje zmìny, které jste neulo¾ili. Pro ka¾dý takový buffer se vás zeptá, zda jej má ulo¾it. >> Vlo¾te øádek textu a pak stisknìte C-x s. Mìli byste být dotázáni, zda má být ulo¾en buffer nazvaný TUTORIAL.cs. Odpovìzte na tuto otázku ano (yes) stiskem "y". * ROZ©IØOVÁNÍ SADY PØÍKAZÙ -------------------------- Existuje mnohem, mnohem více pøíkazù Emacsu, ne¾ které by vùbec mohly být rozmístìny na v¹echny CONTROL a META znaky. Emacs tento problém obchází prostøednictvím X (eXtend) pøíkazu. Ten vzniká dvìma zpùsoby: C-x Znakový eXtend. Následován jedním znakem. M-x Pojmenovaný pøíkaz eXtend. Následován dlouhým názvem. To jsou pøíkazy, které jsou obecnì u¾iteèné, av¹ak ménì èasto pou¾ívané ne¾ ty, které jste se ji¾ nauèili. U¾ jste vidìli dva z nich: souborové pøíkazy C-x C-f pro vyhledání a C-x C-s pro ulo¾ení. Jiný pøíklad je pøíkaz pro ukonèení Emacsu -- tj. pøíkaz C-x C-c. (Nemìjte obavy o ztrátu zmìn, které jste provedli; C-x C-c nabídne ulo¾ení ka¾dého zmìnìného souboru, ne¾ Emacs ukonèí.) C-z je pøíkaz na *doèasné* opu¹tìní Emacsu -- mù¾ete se po nìm do spu¹tìného Emacsu vrátit. Na systémech, které to umo¾òují, C-z Emacs "pozastaví"; tzn. vrátí vás do shellu, av¹ak Emacs neukonèí. V nejbì¾nìj¹ích shellech se mù¾ete do Emacsu vrátit pøíkazem `fg' nebo pomocí `%emacs'. Na systémech, které pozastavování procesù nemají implementováno, C-z vytvoøí subshell bì¾ící pod Emacsem, aby vám dal ¹anci spustit jiné programy a pak se do Emacsu vrátit; neprovede tedy pravé opu¹tìní Emacsu. V tom pøípadì je obvyklou cestou návratu ze subshellu do Emacsu shellovský pøíkaz `exit'. Chvíle pro pou¾ití C-x C-c nastane, kdy¾ se chystáte odhlásit ze systému. Správné je to také pøi ukonèování Emacsu vyvolaného po¹tovním programem a rùznými jinými utilitami, proto¾e ty nemusí vìdìt, jak si poradit s pozastavením Emacsu. Nicménì za normálních okolností, pokud se nechystáte odlogovat, je lépe Emacs pozastavit pomocí C-z ne¾ jej ukonèit. Existuje mnoho C-x pøíkazù. Zde je seznam tìch, které jste se ji¾ nauèili: C-x C-f Vyhledání souboru C-x C-s Ulo¾ení soubor C-x C-b Seznam bufferù C-x C-c Ukonèení Emacsu C-x u Undo Pojmenované eXtended pøíkazy jsou pøíkazy, které jsou pou¾ívány je¹tì ménì, nebo pøíkazy, které jsou pou¾ívány jenom v jistých módech. Pøíkladem je pøíkaz replace-string, který globálnì nahradí jeden øetìzec jiným. Kdy¾ stisknete M-x, vypí¹e se na spodním øádku obrazovky prompt M-x a vy byste mìli zadat jméno pøíkazu; v tomto pøípadì "replace-string". Jednodu¹e napi¹te "repl s<TAB>" a Emacs název doplní. Dokonèete zadávání jména pøíkazu pomocí <Return>. Pøíkaz replace-string vy¾aduje dva argumenty -- øetìzec, který má být nahrazen, a øetìzec, který jej má nahradit. Ka¾dý argument musíte ukonèit pomocí <Return>. >> Pøesuòte kurzor na prázdný øádek dva øádky pod tímto. Pak napi¹te M-x repl s<Return>zmìnil<Return>modifikoval<Return>. V¹imnìte si, jak se tento øádek zmìnil: nahradili jste slovo z-m-ì-n-i-l slovem "modifikoval", kdekoliv se za aktuální pozicí kurzoru vyskytlo. * AUTOMATICKÉ UKLÁDÁNÍ ---------------------- Jestli¾e jste provedli zmìny v souboru, ale nemáte je je¹tì ulo¾eny, mohou být v pøípadì pádu systému ztraceny. Aby vás Emacs od toho uchránil, periodicky zapisuje "auto save" soubor pro ka¾dý soubor, který editujete. Jméno auto save souboru má na zaèátku a na konci #; napøíklad jestli¾e se vá¹ soubor jmenuje "hello.c", jeho auto save soubor se jmenuje "#hello.c#". Kdy¾ soubor ulo¾íte normálním zpùsobem, Emacs auto save soubor sma¾e. Jestli¾e dojde k pádu systému, mù¾ete svoji editaci obnovit z auto-save souboru, a to normálním vyhledáním souboru (toho, který jste editovali, ne auto save souboru) a následnou aplikací M-x recover file<return>. Na ¾ádost o potvrzení odpovìzte zadáním yes<return> pro pokraèování a obnovení auto-save dat. * ECHO OBLAST ------------- Kdy¾ Emacs vidí, ¾e pí¹ete pøíkazy pomalu, ukazuje vám je ve spodní èásti obrazovky v oblasti nazývané "echo oblast". Echo oblast obsahuje dolní øádek obrazovky. * STAVOVÝ ØÁDEK --------------- Øádek bezprostøednì nad echo oblastí se nazývá "stavový øádek" ("mode line"). Stavový øádek øíká nìco jako: 2J:** TUTORIAL.cs (Fundamental)--L670--58%---------------- Tento øádek podává u¾iteènou informaci o stavu Emacsu a textu, který editujete. U¾ víte, co znamená jméno souboru -- je to soubor, který jste vyhledali. -NN%-- oznaèuje va¹i aktuální pozici v textu; øíká, ¾e NN procent textu je nad horním okrajem obrazovky. Je-li zaèátek souboru na obrazovce, je zde --Top-- a ne --00%--. Je-li konec textu na obrazovce, je zde --Bot--. Jestli¾e se díváte na tak malý text, ¾e se celý vejde na obrazovku, stavový øádek øíká --All--. Hvìzdièky poblí¾ zaèátku znamenají, ¾e jste text zmìnili. Tìsnì po vyhledání nebo ulo¾ení souboru v této èásti stavového øádku nejsou ¾ádné hvìzdièky, pouze pomlèky. Èást stavového øádku v závorkách øíká, v jakých editaèních módech se nacházíte. Implicitní mód je Fundamental, co¾ je ten, který momentálnì pou¾íváte. Je pøíkladem hlavního módu ("major mode"). Emacs má celou øadu hlavních módù. Nìkteré z nich jsou urèeny pro editaci rùzných programovacích jazykù a/nebo textù jako tøeba Lisp mód, Text mód, atd. V libovolném okam¾iku je aktivní právì jeden hlavní mód a jeho jméno lze nalézt ve stavovém øádku na místì, kde je teï "Fundamental". Ka¾dý hlavní mód mìní chování nìkterých pøíkazù. Napøíklad existují pøíkazy pro vytváøení komentáøù v programu, a proto¾e ka¾dý programovací programovací jazyk má jinou pøedstavu o tom, jak má komentáø vypadat, musí ka¾dý hlavní mód vkládat komentáøe jinak. Ka¾dý hlavní mód je vlastnì jméno extended pøíkazu, kterým se do tohoto módu mù¾ete pøepnout. Napøíklad M-x fundamental-mode je pøíkaz pro pøepnutí se do Fundamental módu. Chystáte-li se editovat èeský text, jako tøeba tento soubor, pravdìpodobnì byste mìli pou¾ít Text mód. >> Napi¹te M-x text-mode<Return>. Nebojte se, ¾ádný z pøíkazù, které jste se nauèili, chování Emacsu nijak významnì nezmìní. Mù¾ete si ale v¹imnout, ¾e M-f a M-b nyní pracují s apostrofy jako se souèástmi slov. Pøedtím, ve Fundamental módu, M-f a M-b pracovaly s apostrofy coby oddìlovaèi slov. Hlavní módy obvykle dìlají men¹í zmìny, jako byla tato: pøíkazy vìt¹inou dìlají "toté¾", ale v ka¾dém hlavním módu pracují tro¹ku jinak. Dokumentaci k aktuálnímu hlavnímu módu si mù¾ete zobrazit stiskem C-h m. >> Jednou nebo nìkolikrát pou¾ijte C-u C-v, abyste tento øádek dostali k vrcholu obrazovky. >> Stisknìte C-h m, abyste vidìli, jak se Text mód li¹í od Fundamental módu. >> Stisknìte C-x 1 pro odstranìní dokumentace z obrazovky. Hlavní módy se nazývají hlavní proto, ¾e také existují vedlej¹í módy (minor modes). Vedlej¹í módy nejsou alternativou k hlavním módùm, nýbr¾ jejich malé modifikace. Ka¾dý vedlej¹í mód mù¾e být zapnut nebo vypnut sám o sobì nezávisle na v¹ech ostatních vedlej¹ích módech a nezávisle na hlavním módu. Tak¾e nemusíte pou¾ívat ¾ádný vedlej¹í mód nebo mù¾ete pou¾ívat jeden vedlej¹í mód nebo libovolnou kombinaci nìkolika vedlej¹ích módù. Jedním z velmi u¾iteèných vedlej¹ích módù, zejména pro editaci èeských textù, je Auto Fill mód. Kdy¾ je tento mód zapnut, Emacs zalomí øádek mezi dvìma slovy, kdykoliv vkládáte text a øádek se stane pøíli¹ dlouhým. Auto Fill mód mù¾ete zapnout provedením M-x auto-fill-mode<Return>. Je-li tento mód zapnut, mù¾ete jej vypnout provedením M-x auto-fill-mode<Return>. Je-li mód vypnut, tento pøíkaz jej zapíná, a je-li mód zapnut, tak jej tento pøíkaz vypíná. Øíkáme, ¾e tento pøíkaz pøepíná ("toggles") tento mód. >> Napi¹te teï M-x auto-fill-mode<Return>. Pak vkládejte "asdf " stále dokola tak dlouho, a¾ uvidíte, jak se vkládaný øádek rozdìlí na dva øádky. Do textu musíte vkládat mezery proto, ¾e Auto Fill mód zalamuje øádky pouze v mezerách. Okraj je obvykle nastaven na 70 znakù, ale mù¾ete to zmìnit pøíkazem C-x f. Hodnotu okraje, kterou si pøejete, byste mìli pøedat jako numerický argument. >> Napi¹te C-x f s argumentem 20. (C-u 2 0 C-x f). Pak pi¹te nìjaký text a pozorujte, jak Emacs vyplòuje øádky po 20 znacích. Pak nastavte okraj zpátky na 70 opìtovným pou¾itím C-x f. Jestli¾e provedete zmìny uprostøed odstavce, Auto Fill mód jej nepøeformátuje. Pro pøeformátování odstavce stisknìte M-q (META-q) s kurzorem uvnitø odstavce. >> Pøesuòte kurzor do pøedchozího odstavce a stisknìte M-q. * VYHLEDÁVÁNÍ ------------- Emacs umí v textu vyhledávat øetìzce (tj. skupiny spojených znakù nebo slov) smìrem vpøed nebo vzad. Hledání øetìzce je pøíkaz pøesunující kurzor; pøesune kurzor na nejbli¾¹í místo, kde se tento øetìzec nachází. Vyhledávací pøíkaz Emacsu se li¹í od vyhledávacích pøíkazù vìt¹iny editorù v tom smyslu, ¾e je "inkrementální". To znamená, ¾e vyhledávání se provádí u¾ v okam¾iku, kdy zadáváte vyhledávací øetìzec. Pøíkaz pro zahájení hledání vpøed je C-s a pro hledání vzad C-r. ALE POZOR! Nezkou¹ejte to je¹tì. Kdy¾ stisknete C-s, uvidíte v echo oblasti prompt "I-search". To vám øíká, ¾e Emacs se nachází ve stavu, který se nazývá inkrementální hledání, a èeká, a¾ mu zadáte, co chcete hledat. <RET> hledání ukonèí. >> Nyní zahajte hledání stiskem C-s. POMALU, písmeno po písmenu, pi¹te slovo 'kurzor'. Po ka¾dém písmenu si v¹imnìte, co se dìje s kurzorem. Teï jste vyhledali "kurzor" poprvé. >> Stisknìte C-s znovu, abyste nalezli dal¹í výskyt "kurzor". >> Nyní ètyøikrát stisknìte <Delete> a pozorujte, jak se kurzor pøesunuje. >> Stisknìte <RET> pro ukonèení hledání. Vidìli jste, co se stalo? Emacs se v inkrementálním hledání pokou¹í pøejít na dal¹í výskyt øetìzce, který jste dosud napsali. Chcete-li pøejít na dal¹í výskyt 'kurzor', jednodu¹e stisknìte C-s znovu. Jestli¾e u¾ ¾ádný takový výskyt není, Emacs pípne a øekne vám, ¾e hledání momentálnì "selhává", C-g hledání ukonèí. POZNÁMKA: Na nìkterých systémech stisk C-s zpùsobí ztuhnutí obrazovky a nevidíte ¾ádný dal¹í výstup z Emacsu. To znamená, ¾e "vlastnost" operaèního systému zvaná "flow control" zachycuje C-s a nepropustí jej k Emacsu. Pro odtuhnutí obrazovky stisknìte C-q. Pak v sekci "Spontaneous Entry to Incremental Search" v manuálu Emacsu vyhledejte radu, jak se vypoøádat s touto "vlastností". Jestli¾e uprostøed inkrementálního hledání stisknete <Delete>, uvidíte, ¾e poslední znak v hledaném øetìzci zmizí a hledání se vrací na poslední místo hledání. Pøedpokládejme napøíklad, ¾e jste napsali "c", abyste na¹li první výskyt "k". Jestli¾e nyní stisknete "u", kurzor se pøesune na první výskyt "ku". Teï stisknìte <Delete>. To vyma¾e "u" z hledaného øetìzce a kurzor se pøesune zpìt na první výskyt "k". Jestli¾e uprostøed hledání stisknete CONTROL nebo META znak (s nìkolika výjimkami -- znaky, které jsou speciální v hledání, jako C-s a C-r), hledání se ukonèí. C-s zahajuje hledání, které hledá jakýkoliv výskyt hledaného øetìzce ZA aktuální pozicí kurzoru. Chcete-li nìco hledat v pøedcházejícím textu, stisknìte C-r místo C-s. V¹e, co jsme øekli o C-s, platí také o C-r kromì toho, ¾e smìr hledání je opaèný. * VÍCE OKEN ----------- Jednou z pìkných vlastností Emacsu je to, ¾e mù¾e na obrazovce zobrazit více oken souèasnì. >> Pøesuòte kurzor na tento øádek a stisknìte C-u 0 C-l. >> Teï stisknìte C-x 2, co¾ rozdìlí obrazovku na dvì okna. Obì okna zobrazují tento tutoriál. Kurzor zùstává navrchu okna. >> Tisknìte C-M-v pro scrollování spodního okna. (Nemáte-li skuteènou klávesu META, stisknìte ESC C-v.) >> Stisknìte C-x o ("o" jako "other") pro pøesun kurzoru do dolního okna. >> Pou¾ijte C-v a M-v ve spodním oknì pro jeho scrollování. Pokraèujte ve ètení tìchto instrukcí v horním oknì. >> Znovu stisknìte C-x o pro pøesun kurzoru zpìt do horního okna. Kurzor v horním oknì je pøesnì na místì, kde byl pùvodnì. Mù¾ete dále pou¾ívat C-x o pro pøepínání mezi okny. Ka¾dé okno má svoji vlastní pozici kurzoru, ale jenom jedno okno kurzor skuteènì zobrazuje. V¹echny obvyklé editaèní pøíkazy platí pro okno, ve kterém se nachází kurzor. Toto okno nazýváme "aktivní okno" ("selected window"). Pøíkaz C-M-v je velmi u¾iteèný, jestli¾e v jednom oknì editujete text a druhé okno pou¾íváte pouze pro pøehled. Mù¾ete kurzor nechávat stále v oknì, kde editujete, a postupovat po druhém oknì pomocí C-M-v. C-M-v je pøíkladem CONTROL-META znaku. Máte-li skuteènou META klávesu, mù¾ete vyvolat C-M-v pøidr¾ením obou kláves CTRL a META pøi stisku v. Nezále¾í na tom, zda je prvnì stisknuta CTRL nebo META, proto¾e obì tyto klávesy fungují jako modifikátory kláves, které tisknete. Pokud nemáte skuteènou META klávesu, mù¾ete místo ní pou¾ít ESC, na poøadí zále¾í: musíte stisknout ESC a následnì CTRL-v; CTRL-ESC v by nefungovalo. To proto, ¾e ESC je samostatný znak, nikoliv modifikátor. >> Stisknìte C-x 1 (v horním oknì), abyste se zbavili dolního okna. (Kdybyste C-x 1 stiskli v dolním oknì, odstranilo by to horní okno. Chápejte tento pøíkaz jako "ponechej právì jedno okno -- to, ve kterém zrovna jsem".) Nemusíte v obou oknech zobrazovat tentý¾ buffer. Jestli¾e pou¾ijete C-x C-f pro vyhledání souboru v jednom z oken, druhé okno se nezmìní. Mù¾ete vyhledávat soubory v obou oknech nezávisle. Zde je dal¹í zpùsob, jak vyu¾ít dvì okna ke zobrazení dvou rùzných vìcí: >> Stisknìte C-x 4 C-f následované jménem nìkterého z va¹ich souborù. Dokonèete to pomocí <Return>. Vidíte zadaný soubor v dolním oknì. Pøesunul se tam i kurzor. >> Stisknìte C-x o pro pøesun zpìt do horního okna a C-x 1 pro smazání dolního okna. * REKURZIVNÍ EDITAÈNÍ ÚROVNÌ ---------------------------- Obèas se dostanete do nìèeho, co se nazývá "rekurzivní editaèní úroveò" ("recursive editing level"). To je indikováno hranatými závorkami ve stavovém øádku obklopujícími závorky okolo jména hlavního módu. Napøíklad mù¾ete vidìt [(Fundamental)] místo (Fundamental). Abyste se dostali z rekurzivní editaèní úrovnì, stisknìte ESC ESC ESC. To je obecný "vyskakovací" pøíkaz. Mù¾ete jej pou¾ít té¾ pro odstranìní nìkterých oken a vyskoèení z minibufferu. >> Stisknìte M-x, abyste se dostali do minibufferu; pak stisknìte ESC ESC ESC, abyste se z nìj dostali ven. Z rekurzivní editaèní úrovnì nemù¾ete vyskoèit pomocí C-g. To proto, ¾e C-g je vyu¾íváno pro ru¹ení pøíkazù a argumentù UVNITØ rekurzivní editaèní vrstvy. * ZÍSKÁNÍ DAL©Í NÁPOVÌDY ------------------------ V tomto tutoriálu jsme se pokusili poskytnout vám dostatek informací, abyste mohli zaèít Emacs pou¾ívat. V Emacsu je toho tolik, ¾e by bylo nemo¾né to zde v¹echno objasnit. Nicménì se o Emacsu mù¾ete nauèit více, proto¾e má mnoho u¾iteèných vlastností. Emacs nabízí pøíkazy pro ètení dokumentace svých pøíkazù. V¹echny tyto "help" pøíkazy zaèínají znakem CONTROL-h, který se nazývá "help znak". Pro pou¾ití vlastností nápovìdy stisknìte znak C-h a pak znak øíkající, jaký druh nápovìdy ¾ádáte. Jste-li OPRAVDU ztraceni, stisknìte C-h ? a Emacs vám sdìlí, jaké druhy nápovìdy vám mù¾e poskytnout. Jestli¾e jste stiskli C-h a pak jste se rozhodli, ¾e ¾ádnou nápovìdu nechcete, jednodu¹e to zru¹te stiskem C-g. (Na nìkterých poèítaèích je význam znaku C-h zmìnìn. To by opravdu nemìlo být obecným nastavením pro v¹echny u¾ivatele, tak¾e máte právo stì¾ovat si systémovému administrátorovi. Do té doby, jestli¾e C-h nezobrazuje hlá¹ení o nápovìdì v dolní èásti obrazovky, zkuste místo toho pou¾ívat klávesu F1 nebo M-x help RET.) Nejzákladnìj¹í help pøíkaz je C-h c. Stisknìte C-h, znak c a klávesový pøíkaz; Emacs pak zobrazí velmi struèný popis pøíkazu. >> Stisknìte C-h c C-p. Hlá¹ení by mìlo vypadat asi takto C-p runs the command previous-line To vám sdìluje "jméno funkce". Jména funkcí jsou pou¾ívána zejména pro konfiguraci a roz¹iøování Emacsu. Ale proto¾e jména funkcí jsou volena tak, aby naznaèovala, co odpovídající pøíkaz dìlá, mohou slou¾it také jako velmi struèná dokumentace -- dostateèná k tomu, aby vám pøipomenula pøíkazy, které jste se ji¾ nauèili. Víceznakové pøíkazy jako C-x C-s a (pokud nemáte META, EDIT ani ALT klávesu) <ESC>v jsou po C-h c povoleny také. K získání více informací o pøíkazu místo C-h c pou¾ijte C-h k. >> Stisknìte C-h k C-p. To zobrazí dokumentaci k funkci a její jméno v emacsovém oknì. A¾ výstup pøeètete, stisknìte C-x 1, abyste se textu nápovìdy zbavili. Nemusíte to dìlat hned. Mù¾ete chvíli editovat a nahlí¾et do textu nápovìdy a teprve pak stisknout C-x 1. Zde jsou dal¹í u¾iteèné C-h volby: C-h f Popis funkce. Zadáváte jméno funkce. >> Zkuste napsat C-h f previous-line<Return>. To vypí¹e ve¹keré informace, které Emacs má o funkci implementující pøíkaz C-p. Podobný pøíkaz C-h v zobrazí dokumentaci promìnné, její¾ hodnotu mù¾ete nastavit a zmìnit tím chování Emacsu. Jméno promìnné zadáte, a¾ se na nì Emacs zeptá. C-h a Pøíkazové apropos. Zadejte klíèové slovo a Emacs vypí¹e v¹echny pøíkazy, jejich¾ jména obsahují toto klíèové slovo. V¹echny tyto pøíkazy mohou být vyvolány pomocí META-x. Pro nìkteré pøíkazy pøíkazové apropos vypí¹e také jedno nebo dvouznakové sekvence, které provádìjí tentý¾ pøíkaz. >> Napi¹te C-h a file<Return>. To zobrazí v druhém oknì seznam v¹ech M-x pøíkazù obsahujících "file" ve svém názvu. Znakové pøíkazy jako C-x C-f uvidíte vypsané vedle odpovídajících jmen pøíkazù jako find-file. >> Stisknìte C-M-v pro posun okna s nápovìdou. Proveïte to nìkolikrát. >> Stisknìte C-x 1 pro smazání okna s nápovìdou. C-h i Ètení on-line manuálù (té¾ Info). Tento pøíkaz vás pøepne do speciálního bufferu s názvem `*info*', ve kterém mù¾ete èíst on-line manuály pro balíky nainstalované na va¹em systému. Pokud stisknete m emacs <Return> mù¾ete si napøíklad pøeèíst manuál k Emacsu. Pokud jste dosud nikdy nepou¾ívali Info, stisknìte ? a Emacs vám pøedstaví hlavní mo¾nosti módu pro Info. A¾ si tyto mo¾nosti prostudujete, mìli byste pou¾ívat Info manuál Emacsu jako svoji primární dokumentaci. * ZÁVÌR ------- Nezapomeòte, Emacs ukonèíte provedením pøíkazu C-x C-c. Pro doèasný odskok do shellu, ze kterého se do Emacsu mù¾ete opìt vrátit, pou¾ijte C-z. Zámìrem tohoto tutoriálu je být srozumitelný v¹em novým u¾ivatelùm, tak¾e narazíte-li na nìco nejasného, tak neusedejte a neklaïte to za vinu sobì -- stì¾ujte si! KOPÍROVÁNÍ ---------- Tento tutoriál vychází z dlouhé øady emacsových tutoriálù zahájené tutoriálem napsaným Stuartem Cracraftem pro pùvodní Emacs. Tato verze tutoriálu je, podobnì jako GNU Emacs, chránìna copyrightem a je ¹íøena se svolením distribuovat kopie za jistých podmínek: Copyright (c) 1985, 1996 Free Software Foundation Ka¾dému je zaruèeno právo vytváøet a distribuovat pøesné kopie tohoto dokumentu tak, jak jej obdr¾el, na jakémkoliv médiu, s tím, ¾e bude zachována tato poznámka o autorství a poznámka o svolení a ¾e distributor zaruèuje pøíjemci právo na dal¹í redistribuci povolenou touto poznámkou. Je zaruèeno právo distribuovat modifikované verze tohoto dokumentu nebo jeho èástí pod vý¹e uvedenými podmínkami za pøedpokladu, ¾e obsahuje jasné poznámky uvádìjící, kdo provedl poslední modifikace. Podmínky pro kopírování Emacsu samotného jsou slo¾itìj¹í, av¹ak ve stejném duchu. Pøeètìte si prosím soubor COPYING a pak pøedávejte kopie GNU Emacsu svým pøátelùm. Pomáhejte potírat softwarovou obstrukci ("vlastnictví") pou¾íváním, psaním a sdílením free softwaru! ;;; Local Variables: ;;; coding: iso-latin-2 ;;; End:

3 participants
6 comments

[comp.emacs.xemacs] core dump on SunOS 5.7 sun4u 23 years, 1 month

Adrian Aichner

Hi Carl, please install the latest version of the net-utils package (1.23) and then use Help/Send Bug Report ... or M-x report-emacs-bug to provide a better bug report with lots of information automatically included for you (you can review it all before sending). If you could compile XEmacs with debug information, the C Backtrace would be even more valuable. Best regards, Adrian -- Adrian Aichner mailto:adrian＠xemacs.org http://www.xemacs.org/

1 participants
0 comments

displaying directory 23 years, 1 month

James Bryant

Does anyone know how to display the path a particular file is located in when it is open in emacs (either within a title bar or anyot? IF YOU DO PLEAESE RESPOND TO ME AT: jcbryant(a)cisco.com Sorry for the trivial question if it is on. I am not that experienced in configuring xemacs. THANKS!!! _______________________________ James Bryant Software Engineer Cisco Systems Bradenton, FL 941-708-4734

4 participants
3 comments

Re: Xemacs 21.4.3 generating .#Filename file when editing 23 years, 1 month

Adrian Aichner

The following message is a courtesy copy of an article that has been posted to comp.emacs.xemacs as well. >>>>> "Jonathan" == Jonathan Albrecht <albrecht(a)algorithmics.com> writes: Jonathan> Sorry, I don't see how this could be a cvs interation. I Jonathan> am not using cvs. The .# files are created by xemacs Jonathan> 21.4.3 when I make changes in a buffer corresponding to Jonathan> a visited file. Here is the description of the behaviour Jonathan> I see: Jonathan> If I am editing a file on a NT filesystem the .# file Jonathan> only exists while the buffer for the file has unsaved Jonathan> changes. On NT, as soon as I save the file, the Jonathan> corresponding .# file is deleted. If the file being Jonathan> edited is on a samba filesystem, the .#file is not Jonathan> deleted. Jonathan> It seems to me that the .# file is just there to show Jonathan> that the buffer and its corresponding file are out of Jonathan> sync. I see that the .# filename format is the same Jonathan> format as for files in which merge collisions have Jonathan> occured in cvs, but I think that is just a coincidence Jonathan> in this case. Unless PCL-CVS is doing something wacky to Jonathan> every file being edited. Hi Jonathan, what do you use PCL-CVS for, when you are not using cvs? Anyway, I think Eli is right. These are probably interlocking files. See: http://cvs.xemacs.org/cgi-bin/cvswebxe/xemacs/src/filelock.c?rev=1.11 I don't have file-locking in my native Windows 2000 XEmacs. All I can suggest is this: (setq inhibit-clash-detection nil) Hope this helps, Adrian Jonathan> Thanks, Jonathan> Jon Jonathan> Adrian Aichner wrote: >>>>>>> "Jonathan" == Jonathan Albrecht <albrecht(a)algorithmics.com> writes: >>>>>>> Jonathan> I just tried XEmacs 21.1.13 and it does not create the Jonathan> .# files. Anyone know what they are for? >> For an answer to your question see the CVS manuals. >> If you have cvs Info files installed following sexp should beam you >> there: >> (Info-goto-node "(cvs)update output") >> Best regards, >> Adrian Jonathan> Jon Jonathan> Jonathan Albrecht wrote: >> >> No the .# files do not go away when I exit XEmacs. If I am >> >> editing a >> >> file on a NT filesystem the .# file only exists while the buffer for >> >> the file has unsaved changes. On NT, as soon as I save the file, the >> >> corresponding .# file is deleted. If the file being edited is on a >> >> samba filesystem, the .#file is not deleted. I don't know if this is >> >> an XEmacs or cygwin problem. >> >> Jon >> >> David Masterson wrote: >> >> >>> IIRC, the '.#' files don't have anything to do with >> >> >>> CVS (or the Emacs >> >>> interface to CVS) -- I believe its created by auto-save-mode, but I >> >>> could be wrong (auto-save files are '#file#'?). This facility is >> >>> (mostly?) built-in, so it wouldn't show up in the .el files (unless >> >>> you really know what you're looking for). Also, although I said the >> >>> '!<symlink>' is a Cygwin symlink, I'm not sure what it's a symlink to. >> >>> >>> Does the .# file go away when you exit Emacs? If >> >>> >>> so, don't worry >> >>> about it -- Emacs is handling it. >> >>> >>> What I haven't figured out is how to handle the >> >>> >>> '.saves-*' files that >> >>> (X)Emacs generates on all platforms I use it on. They don't seem to >> >>> go away unless I specifically delete them. >> >>> >>> >>>>>>>> Jonathan Albrecht writes: >> >>>>>>>> >>> >>>> Thanks for the info. So it seems that >> >>>>>>>> >>> >>>> xemacs is trying to make a >> >>>> symlink of the form: >> >>>> >>> >>>> .#filename >> >>>> >>> >>>> to the file: >> >>>> >>> >>>> filename >> >>>> >>> >>>> for some reason. I've been grepping >> >>>> >>> >>>> through the .el files for .# but >> >>>> the only thing I've found is some cvs related stuff. I'm not using >> >>>> cvs. Does anyone know what else .# prefixed files are used for? I >> >>>> don't think it's auto-save, those filenames are of the form #filename# >> >>>> I believe. I'll look into it some more though. >> >>>> >>> >>>> Jon >> >>>> >>> >>>> David Masterson wrote: >> >>>> >>> >>>>>>>>>> Jonathan Albrecht writes: >> >>>>>>>>>> >>>>>>>>>> >>>>>>> I am using Xemacs 21.4.3 on cygwin. I am finding that when I edit file >>>>>>> there is another file generated with the same filename but prefixed >>>>>>> with '.#'. The contents of the file are: >>>>>>> >> >>>>>> >>>>>> >>>>>>> !<symlink>albrecht(a)toralbrecht.myhost.com.328^＠ >>>>>>> >> >>>>>> >>>>>> >>>>>>> anyone know what is generating these files? >>>>>>> >> >>>>>> >>>>>> >>>>> Not off-hand. The ".#" files are >> >>>>>> >>>>>> >>>>> temporary Emacs (autosave?) files >> >>>>> for the file you're currently editing and should go away when you save >> >>>>> the file. The "!<symlink>" file is a symbolic link in Cygwin. >> >>>>> >>>>> >>> >>> >> -- Adrian Aichner mailto:adrian＠xemacs.org http://www.xemacs.org/

1 participants
0 comments

Re: XEmacs FAQ 23 years, 1 month

Adrian Aichner

>>>>> "Mohamed" == Mohamed Ghanem <Mohamed.Ghanem(a)peregrine.com> writes: Mohamed> Hi, Mohamed> I have a question which I tried to find an answer for in Mohamed> the online FAQ and elsewhere. I just downloaded Mohamed> xemacs-21.4.4 and compiled it for Solaris 2.6. I Mohamed> discovered that the right shif key on my keyboard types Mohamed> an asterisk '*' every time I press it. For example, if I Mohamed> type on the Shift-4 to insert '$' in my buffer, I get Mohamed> '*$'. Would you happen to know why this is happening? I Hi Mohamed, does this only happen in XEmacs 21.4.4? Does it also happen when you start XEmacs as follows? xemacs -vanilla If not, then you have to check your init files (~/.emacs, ~/.xemacs/init.el, ~/.xemacs/custom.el, site-start.el) for the reason. Do you have an older XEmacs, or even GNU Emacs, that you could try this in? Does this happen in shell windows too? Does it happen in vi, if you ever use that one? Best regards, Adrian Mohamed> have always used XEmacs (since version 19 to be exact) Mohamed> and never got this. Is there any key mapping that are Mohamed> assumed in 21.4.4? I had 21.1 before that and was working Mohamed> perfectly fine. Mohamed> Sincerely, Mohamed> M. Ezz -- Adrian Aichner mailto:adrian＠xemacs.org http://www.xemacs.org/

1 participants
0 comments

[ANNOUNCE] Updated Packages Released - Oct 5 23 years, 1 month

Steve Youngs

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hello. The following XEmacs packages have just been released. Updated or New Packages: ======================= ediff-1.33-pkg.tar.gz edit-utils-1.70-pkg.tar.gz net-utils-1.23-pkg.tar.gz prog-modes-1.42-pkg.tar.gz viper-1.28-pkg.tar.gz xemacs-devel-1.38-pkg.tar.gz Detailed Changes: ================ ediff-1.33-pkg.tar.gz: - --------------------- 2001-09-27 Michael Kifer <kifer(a)cs.sunysb.edu> * ediff-mult.el (ediff-get-meta-info): Installed Gerd's changes. Added comments. 2001-09-09 Michael Kifer <kifer(a)cs.sunysb.edu> * ediff-init.el (ediff-highest-priority): bug fix. * ediff-mult.el (ediff-get-meta-info): replace and with or. edit-utils-1.70-pkg.tar.gz: - -------------------------- 2001-09-29 Jeff Mincy <jeff(a)delphioutpost.com> * recent-files.el (recent-files-entry-to-menu-entry): Don't prepend "*" if in a submenu. net-utils-1.23-pkg.tar.gz: - ------------------------- 2001-09-28 Stephen J. Turnbull <stepheen(a)xemacs.org> * xemacsbug.el (report-emacs-bug): Missing autoload. prog-modes-1.42-pkg.tar.gz: - -------------------------- 2001-06-19 Barry Warsaw <barry(a)xemacs.org> * python-mode.el (python-font-lock-keywords): Add "yield" as a keyword to support the new "simple generators" feature of 2.2. See PEP 255. 2001-06-18 Barry Warsaw <barry(a)xemacs.org> * python-mode.el (py-continuation-offset): New variable which controls how much to indent continuation lines, defined as lines following those that end in backslash continuing a block opening statement. 2001-09-10 Raymond Toy <toy(a)rtp.ericsson.se> * fortran.el (fortran-mode-map): Keep M-BS as backward-kill-word and make C-M-h 'mark-fortran-subprogram. viper-1.28-pkg.tar.gz: - --------------------- 2001-09-13 Michael Kifer <kifer(a)cs.sunysb.edu> * viper-cmd.el (viper-replace-char-subr, viper-envelop-ESC-key): inhibit quit. 2001-09-09 Michael Kifer <kifer(a)cs.sunysb.edu> * viper-cmd.el (viper-special-read-and-insert-char): new function that reads a character and uses the current input method or iso-accents when appropriate. * viper.el and all others: corrections to the comment blocks at the top. xemacs-devel-1.38-pkg.tar.gz: - ---------------------------- 2001-09-08 Adrian Aichner <adrian(a)xemacs.org> * bench.el (bench-large-lisp-file): Use expand-file-name instead of concat to build path. * bench.el (bench-small-lisp-file): Ditto. 2001-09-04 Jeff Mincy <jeff(a)delphioutpost.com> * hide-copyleft.el (hide-copyleft-region): Make it interactive. Installing These: ================ Manually: - -------- 1) Download the packages that you want to install from: [1] /ftp.xemacs.org:/pub/xemacs/packages/ 2) Unpack them to: [2] /usr/local/lib/xemacs/xemacs-packages/ 3) Re-start XEmacs. Using XEmacs Package Tools (XEmacs 21.[245].x): - ---------------------------------------------- 1) Tools -> Packages -> Add Download Site -> choose site 2) Tools -> Packages -> List and Install 3) Select the packages you wish to install (there are brief instructions at the bottom of the packages buffer). 4) Packages -> Install/Remove Selected 5) Re-start XEmacs. Using XEmacs Package Tools (XEmacs 21.1.14): - ------------------------------------------- 1) Options -> Manage Packages -> Add Download Site -> choose site 2) Options -> Manage Packages -> List and Install 3 - 5) As per XEmacs 21.[245].x. Footnotes: [1] Or from a mirror near you. [2] Note: Mule packages should be installed into: /usr/local/lib/xemacs/mule-packages/ - -- |---<Steve Youngs>---------------<GnuPG KeyID: 9E7E2820>---| | XEmacs - It's not just an editor. | | It's a way of life. | |------------------------------------<youngs(a)xemacs.org>---| -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.0.6 (GNU/Linux) Comment: The XEmacs Development Team. iD8DBQE7vNoNY2VD3p5+KCARAlzMAJ9L9i/EhbxcNm8l+J/TGpnvl6eJSwCgohpO f5fmAa9wAeiIL+k1R6PpMOI= =8FoD -----END PGP SIGNATURE-----

2 participants
3 comments

[ANNOUNCE] New Sumo Packages Released. 23 years, 1 month

Steve Youngs

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hi Folks! I've just uploaded new Sumo's to ftp.xemacs.org. They are in the normal place (/pub/xemacs/packages/). Updated Packages in this Sumo Release: - ------------------------------------- auctex-1.25-pkg.tar.gz bbdb-1.16-pkg.tar.gz calc-1.17-pkg.tar.gz cc-mode-1.26-pkg.tar.gz edebug-1.14-pkg.tar.gz ediff-1.33-pkg.tar.gz edit-utils-1.70-pkg.tar.gz edt-1.12-pkg.tar.gz eudc-1.34-pkg.tar.gz gnus-1.57-pkg.tar.gz ispell-1.23-pkg.tar.gz net-utils-1.23-pkg.tar.gz pcl-cvs-1.55-pkg.tar.gz prog-modes-1.42-pkg.tar.gz semantic-1.10-pkg.tar.gz speedbar-1.21-pkg.tar.gz supercite-1.18-pkg.tar.gz text-modes-1.32-pkg.tar.gz tm-1.29-pkg.tar.gz vc-1.28-pkg.tar.gz viper-1.28-pkg.tar.gz vm-6.96-pkg.tar.gz xemacs-devel-1.38-pkg.tar.gz xslt-process-1.05-pkg.tar.gz zenirc-1.11-pkg.tar.gz The following packages are NOT in the Sumo: - ------------------------------------------ Sun-1.13-pkg.tar.gz - Right now I can't remember the reason this package was left out. If you think that you need it you can easily grab it using the normal XEmacs package tools. eicq-1.05-pkg.tar.gz - This package will only run on GNU/Linux x86 systems. jde-1.30-pkg.tar.gz - This package has some tar related issues that hopefully will be resolved in the next release. dictionary-1.00-pkg.tar.gz - The truth of the matter here is that this is a new package and I simply forgot to include it in the Sumo. It'll definitely be in the next Sumo. All of those packages are available using the normal XEmacs package tools. - -- |---<Steve Youngs>---------------<GnuPG KeyID: 9E7E2820>---| | XEmacs - It's not just an editor. | | It's a way of life. | |------------------------------------<youngs(a)xemacs.org>---| -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.0.6 (GNU/Linux) Comment: The XEmacs Development Team. iD8DBQE7vOUuY2VD3p5+KCARAuINAKCPnD5fK/lY1FlfcxbCy5uSG1aWHgCgyPbn UI+/nPYAMmxr4biokEl4F8E= =XfnN -----END PGP SIGNATURE-----

1 participants
0 comments

xemacs XmProcessTraversal crash on HPUX 23 years, 1 month

Steven_Gillard.AMAWORLD＠amadeus.net

I've seen this crash in two different cases: - when exiting xemacs without saving changes to a file - when attempting to update packages I'm certain this problem will occur any time xemacs attempts to create a simple question dialog box. It crashes during a call to XmProcessTraversal made in the make_dialog function of lwlib-Xm.c. I did some further digging into the core with gdb and found that the 'value' variable which is passed to XmProcessTraversal as the widget id is 0, hence the crash. This will occur if the text_input_slot, radio_box and list are all false. I've hacked around the problem by making the following change to the make_dialog function in lwlib/lwlib-Xm.c: # diff lwlib-Xm.c lwlib-Xm.c.orig 1272c1272 < else if (value != 0) --- > else It now displays a somewhat strange looking yet functional question dialog box, but it doesn't crash. Platform: HP L2000 running HPUX 11.0 Here's the stack trace: (gdb) bt #0 0xc01f45a0 in kill () from /usr/lib/libc.2 #1 0x94fdc in fatal_error_signal (sig=2138629244) at emacs.c:264 #2 <signal handler called> #3 0xc32a14c0 in XtWidgetToApplicationContext () from /usr/lib/X11R6/libXt.3 #4 0xc3976ac0 in XmProcessTraversal () from /usr/lib/libXm.4 #5 0x1a8b38 in make_dialog (name=0x0, parent=0x7f7076d5, pop_up_p=80 'P', shell_title=0x40309200 "＠0\222", icon_name=0x1cbc2c "dbox-question", text_input_slot=0 '\000', radio_box=0 '\000', list=0 '\000', left_buttons=6, right_buttons=0) at lwlib-Xm.c:1275 #6 0x1a91f4 in xm_create_dialog (instance=0x40305f80) at lwlib-Xm.c:1482 #7 0x1a04a0 in instantiate_widget_instance (instance=0x40305f80) at lwlib.c:866 #8 0x1a05dc in lw_make_widget (id=0, parent=0x40274e00, pop_up_p=1 '\001') at lwlib.c:345 #9 0x1a10c0 in lw_create_widget (type=0x400b9280 "Q6BR0", name=0x1bc298 "dialog", id=65540, val=0x40286f40, parent=0x40274e00, pop_up_p=1, pre_activate_cb=0, selection_cb=0x400b5772 <dbox_selection_callback>, post_activate_cb=0) at lwlib.c:918 #10 0xb9634 in x_popup_dialog_box (f=0x40274e00, dbox_desc=0) at dialog-x.c:228 #11 0xb20a0 in Fpopup_dialog_box (dbox_desc=1075093796) at dialog.c:77 #12 0x9a408 in funcall_recording_as (recorded_as=0, nargs=1, args=0x7f7f3980) at eval.c:3197 #13 0x9f8a0 in Ffuncall (nargs=0, args=0x7f717d50) at eval.c:3238 #14 0x6ed78 in Fbyte_code (bytestr=2139044040, vector=2139044088, maxdepth=1) at bytecode.c:416 #15 0x7f7f3980 in ?? () #16 0x94fdc in fatal_error_signal (sig=1074498056) at emacs.c:264 If you need any further info, let me know. Regards, Steve UNIX Systems Administrator Amadeus Services Ltd, UK

1 participants
0 comments

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

XEmacs-Beta October 2001