1 ;; -*- Mode: Emacs-Lisp -*-
3 ;; Copyright (C) 2000, 2001 Ben Wing.
5 ;; Author: Mostly Ben Wing <ben@xemacs.org>
6 ;; Maintainer: XEmacs Development Team
7 ;; Keywords: sample, initialization
9 ;; This file is part of XEmacs.
11 ;; XEmacs is free software; you can redistribute it and/or modify it
12 ;; under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
16 ;; XEmacs is distributed in the hope that it will be useful, but
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 ;; General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with XEmacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
27 ;; -- #### figure out how init.el and custom.el interact and put
28 ;; documentation about it here. (perhaps it already exists
31 ;;; This is a sample init.el file. It can be used without
32 ;;; modification as your init.el or .emacs. In older versions of
33 ;;; XEmacs, this file was called .emacs and placed in your home
34 ;;; directory. (Under MS Windows, that directory is controlled by the
35 ;;; HOME environment variable and defaults to C:\. You can find out
36 ;;; where XEmacs thinks your home directory is using
38 ;;; ESC : (expand-file-name "~")
40 ;;; . This means type ESC, then colon, then the following text, then hit
41 ;;; return.) In more recent versions of XEmacs, this file has migrated to
42 ;;; the .xemacs/ subdirectory and is called init.el. Other files are
43 ;;; also located here, such as custom.el (the auto-generated file
44 ;;; containing Customization options that you saved when using
45 ;;; Options->Save Options).
47 ;;; Changes to your init.el file will not take effect until the next
48 ;;; time you start up XEmacs, unless you load it explicitly with
50 ;;; M-x load-file RET ~/.xemacs/init.el RET
52 ;;; The language that this file (and most other XEmacs init files) is
53 ;;; written in is called "XEmacs Lisp" or more commonly "Elisp".
55 ;;; There are many sources of further information:
57 ;;; -- the XEmacs User's Manual (Access using the online Info browser:
58 ;;; Use `Help->Info (Online Docs)->XEmacs User's Manual' (if
59 ;;; there is such an entry); or get to the Info contents page
60 ;;; using `Help->Info Contents' or `C-h i', and then
61 ;;; *middle-click* the XEmacs link or move the cursor into the
62 ;;; link and hit ENTER. This manual contains a great deal of
63 ;;; documentation on customization: Scroll down to the
64 ;;; Customization link and select it in the same fashion as for
65 ;;; the XEmacs link just mentioned.)
67 ;;; -- the XEmacs FAQ (`C-h F' for the local version; get either the
68 ;;; local version or the very latest version off the net using
71 ;;; -- the XEmacs Lisp Reference Manual, containing detailed
72 ;;; documentation on Elisp. (Access using Info, just like for the
73 ;;; XEmacs User's Manual.)
75 ;;; -- the documentation strings for specific commands, functions,
76 ;;; key sequences, and variables. NOTE: This is *not* the same
77 ;;; information as in the XEmacs User's Manual or XEmacs Lisp
78 ;;; Reference Manual! In general, the doc strings are more
79 ;;; terse and more up-to-date than what is found in the manuals.
80 ;;; Once you understand the general concepts, these doc strings
81 ;;; should be your first point of reference for further
82 ;;; info. (Access using menu entries under `Help->Commands,
83 ;;; Variables, Keys' or using the keyboard: `C-h k' for a key
84 ;;; sequence, `C-h f' for a named command or Elisp function,
85 ;;; `C-h v' for a variable. There is various other useful
86 ;;; information accessible similarly, such as `C-h a'
87 ;;; ["Apropos", i.e. search for a command, function, or variable
88 ;;; by name]; `C-h C-a' ["Apropos Docs", i.e. search through the
89 ;;; text of the doc strings]; `C-h b' to list all key bindings;
90 ;;; `C-h m' to describe the current major and minor modes; etc.
91 ;;; Type `C-h ? ?' for a complete list.)
93 ;;; -- Getting Started with XEmacs [aka the "New User's Guide"], a
94 ;;; more introductory manual than the XEmacs User's Manual.
95 ;;; (Access using Info, just like for the XEmacs User's Manual.
96 ;;; There are some sections on customization here.)
98 ;;; -- the XEmacs tutorial, a very simple introduction to XEmacs for
99 ;;; total beginners. (`C-h t' for English; get the version in
100 ;;; various languages from the Help menu)
102 ;;; -- the XEmacs web site, www.xemacs.org.
104 ;;; -- the XEmacs mailing lists (xemacs-FOO@xemacs.org;
105 ;;; see http://www.xemacs.org/Lists/ for more info. Before
106 ;;; posting, consider looking through the archives -- they go back
107 ;;; years and there is a powerful searching interface. Currently
108 ;;; the archives are at http://list-archive.xemacs.org/, but if
109 ;;; this doesn't work, you can always access them through
112 ;;; -- the XEmacs newsgroup, comp.emacs.xemacs. This is
113 ;;; bi-directionally gatewayed with xemacs@xemacs.org. WARNING:
114 ;;; The developers do not normally hang out on this newsgroup. If
115 ;;; you need to contact them, use xemacs-beta@xemacs.org.
117 ;;; -- the XEmacs internals manual, for those interested in working on
118 ;;; the XEmacs C code. (Available through Info.)
120 ;;; -- `Help->About XEmacs' to find out who the maintainers are.
123 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
124 ;; Basic Customization ;;
125 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
127 ;; TIP: Control-L characters are ignored in Lisp files and are the
128 ;; standard way of indicating major section divisions. You can enter
129 ;; such a character using C-q C-l.
131 ;; Define a variable to indicate whether we're running XEmacs/Lucid
132 ;; Emacs. (You do not have to defvar a global variable before using
133 ;; it -- you can just call `setq' directly. It's clearer this way,
134 ;; though. Note also how we check if this variable already exists
135 ;; using `boundp', because it's defined in recent versions of
138 (or (boundp 'running-xemacs)
139 (defvar running-xemacs (string-match "XEmacs\\|Lucid" emacs-version)))
141 ;; Define a function to make it easier to check which version we're
142 ;; running. This function already exists in recent XEmacs versions,
143 ;; and in fact all we've done is copied the definition. Note again
144 ;; how we check to avoid clobbering an existing definition. (It's good
145 ;; style to do this, in case some improvement was made to the
146 ;; already-existing function -- otherwise we might subsitute an older
147 ;; definition and possibly break some code elsewhere.)
149 ;; NOTE ALSO: It is in general *NOT* a good idea to do what we're
150 ;; doing -- i.e. provide a definition of a function that is present in
151 ;; newer versions of XEmacs but not older ones. The reason is that it
152 ;; may confuse code that notices the presence of the function and
153 ;; proceeds to use it and other functionality that goes along with it
154 ;; -- but which we may not have defined. What's better is to create
155 ;; the function with a different name -- typically, prefix it with the
156 ;; name of your module, which in this case might be `Init-'. For
157 ;; `emacs-version>=' we make an exception because (a) the function has
158 ;; been around a long time, (b) there isn't really any other
159 ;; functionality that is paired with it, (c) it's definition hasn't
160 ;; changed and isn't likely to, and (d) the calls to `emacs-version>='
161 ;; or its renamed replacement would be scattered throughout the code
162 ;; below, and with a replacement name the code would become
163 ;; significantly less portable into someone else's init.el file. (BUT
164 ;; NOTE BELOW: We do follow the procedure outlined above with renaming
165 ;; in a different case where the specifics are much different.)
167 ;; TIP: At this point you may be wondering how I wrote all these nice,
168 ;; long, nicely-justified textual stretches -- didn't I go crazy
169 ;; sticking in the semicolons everywhere and having to delete them and
170 ;; rearrange everything whenever I wanted to make any corrections to
171 ;; the text? The answer is -- of course not! Use M-q. This does all
172 ;; the magic for you, justifying and breaking lines appropriately and
173 ;; putting any necessary semicolons or whatever at the left (it
174 ;; figures out what this ought to be by looking in a very clever
175 ;; fashion at what's already at the beginning of each line in the
176 ;; paragraph). You may need `filladapt' set up (it's done below in
177 ;; this file) in order for this to work properly. Finally, if you
178 ;; want to turn on automatic filling (like in a word processor, but
179 ;; not quite as automatic), use M-x auto-fill-mode or the binding set
180 ;; up below in this file (Meta-F9).
182 (or (fboundp 'emacs-version>=)
183 (defun emacs-version>= (major &optional minor patch)
184 "Return true if the Emacs version is >= to the given MAJOR, MINOR,
186 The MAJOR version number argument is required, but the other arguments
187 argument are optional. Only the Non-nil arguments are used in the test."
188 (let ((emacs-patch (or emacs-patch-level emacs-beta-version -1)))
189 (cond ((> emacs-major-version major))
190 ((< emacs-major-version major) nil)
192 ((> emacs-minor-version minor))
193 ((< emacs-minor-version minor) nil)
195 ((>= emacs-patch patch))))))
197 ;; 19.13 was released ages ago (Sep. 1995), and lots of graphic and
198 ;; window-system stuff doesn't work before then.
200 (or (not running-xemacs)
201 (emacs-version>= 19 13)
202 (error "This init file does not support XEmacs before 19.13"))
204 ;; Here are some example code snippets that you can use if you need to
205 ;; conditionalize on a particular version of Emacs (in general, though,
206 ;; it is much better to use `fboundp', `featurep', or other such
207 ;; feature-specific checks rather than version-specific checks):
209 ; (cond ((and running-xemacs
210 ; (emacs-version>= 21 2))
212 ; ;; Code requiring XEmacs version 21.2 or newer goes here
216 ; (cond ((emacs-version >= 19 0)
218 ; ;; Code for any vintage-19 Emacs goes here
222 ; (cond ((and (not running-xemacs)
223 ; (emacs-version>= 20 0))
225 ; ;; Code specific to GNU Emacs 20 or newer (not XEmacs) goes here
230 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
231 ;; Key Definitions ;;
232 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
234 ;;; Set up the function keys to do common tasks to reduce Emacs pinky
237 ;; You can set a key sequence either to a command or to another key
238 ;; sequence. (Use `C-h k' to map a key sequence to its command. Use
239 ;; `C-h w' to go the other way.) In general, however, it works better
240 ;; to specify the command name. For example, it does not currently
243 ;; (global-set-key 'f5 "\C-x\C-f")
245 ;; The reason is that macros (which is what the string on the right
246 ;; really is) can't currently use the minibuffer. This is an
247 ;; extremely longstanding bug in Emacs. Eventually, it will be
248 ;; fixed. (Hopefully ..)
250 ;; Note also that you may sometimes see the idiom
252 ;; (define-key global-map ...)
254 ;; in place of (global-set-key ...). These are exactly the same.
256 ;; Here I've tried to put all the most common commands on simple
257 ;; non-modifier function keys to take the pressure off your modifier
258 ;; fingers. Furthermore, on my keyboard at least, the function keys
259 ;; are grouped into three groups of four with spaces between them, and
260 ;; so it's easier to hit the keys at the edge of the groups --
261 ;; i.e. f1, f4, f5, f8, f9, and f12. Finally, you may note that f9,
262 ;; f11, and f12 are purposely left blank. [F6 is defined below.]
263 ;; That's because I use them for _, {, and } -- see below.
265 (global-set-key 'f1 'advertised-undo) ;; Undo
266 (global-set-key 'f2 'kill-primary-selection) ;; Cut
267 (global-set-key 'f3 'copy-primary-selection) ;; Copy
268 (global-set-key 'f4 'yank-clipboard-selection) ;; Paste
269 (global-set-key 'f5 'find-file) ;; C-x C-f
270 (global-set-key 'f7 'save-buffer) ;; C-x C-s
272 ;; I considered having this retain the current column after killing
273 ;; the line, but that messes up the common idiom `f8 move-cursor f4'.
275 (defun Init-kill-entire-line (&optional arg)
276 "Kill the entire line.
277 With prefix argument, kill that many lines from point. Negative
278 arguments kill lines backward.
280 When calling from a program, nil means \"no arg\",
281 a number counts as a prefix arg."
283 (let ((kill-whole-line t))
285 (call-interactively 'kill-line)))
288 (if (fboundp 'kill-entire-line) 'kill-entire-line 'Init-kill-entire-line))
290 ;; A keystroke repeated incredible amounts of times. We need to patch
291 ;; into the isearch keymap so that repeat searches while in isearch
292 ;; mode still work. Here we show how to make a key in a keymap have the
293 ;; same binding as another key in the keymap, without knowing what the
294 ;; binding is in advance; instead, we find it with `lookup-key'. This
295 ;; way, if the binding of C-s changes (e.g. to a different function) but
296 ;; the meaning is basically the same, we automatically do the right thing.
297 ;; If we put in the actual binding, which is 'isearch-repeat-forward,
298 ;; this automatic tracking wouldn't happen.
300 ;; TIP: To find out what the (lookup-key ...) expression evaluates to,
301 ;; move just to the right of the closing paren and type C-x C-e.
303 (global-set-key 'f10 'isearch-forward)
304 (define-key isearch-mode-map 'f10 (lookup-key isearch-mode-map "\C-s"))
305 (define-key minibuffer-local-isearch-map 'f10
306 (lookup-key minibuffer-local-isearch-map "\C-s"))
307 (global-set-key '(shift f10) 'isearch-backward)
308 (define-key isearch-mode-map '(shift f10) (lookup-key isearch-mode-map "\C-r"))
309 (define-key minibuffer-local-isearch-map '(shift f10)
310 (lookup-key minibuffer-local-isearch-map "\C-r"))
312 ;; Here we define our own function and then bind a key to it.
314 (defun start-or-end-kbd-macro ()
315 ;; A doc string. This is optional.
316 "Start defining a keyboard macro, or stop if we're already defining."
317 ;; IMPORTANT: Any function bound to a key MUST have an interactive spec,
318 ;; usually just the following line:
320 (if defining-kbd-macro
322 (start-kbd-macro nil)))
324 ;; The macros used to have their place in the function keys, but I
325 ;; find that I use them significantly less than the really basic
326 ;; things on the function keys. When using a macro, you call the
327 ;; macro much more than define it, so the setup below makes some
330 (global-set-key '(shift kp-multiply) 'start-or-end-kbd-macro)
331 (global-set-key 'kp-multiply 'call-last-kbd-macro) ;; C-x e
333 ;; Note that you can refer to a key sequence either using an ASCII
334 ;; string or the "long way", with vectors and conses. You saw above
335 ;; (in a comment) the string form for specifying the key sequence `C-x
336 ;; C-f', which is "\C-x\C-f". (For those curious, \C-x is just an
337 ;; escape sequence that puts a ^X character into the string. Thus,
338 ;; the string just mentioned really just contains two characters, a ^X
339 ;; and a ^F.) The long way to specify the sequence `C-x C-f' would be
341 ;; [(control x) (control f)]
343 ;; The long format lets you specify all possible key sequences, while the
344 ;; string form only lets you specify sequences involving ASCII characters
345 ;; and/or modifiers and in fact only a subset of them.
347 ;; Other examples are:
351 ;; (You can leave out the parens when there is no modifier specified in
352 ;; the keystroke, and that's normally done.)
354 ;; [(shift control meta left)]
356 ;; (You can put more than one modifier in a keystroke.)
358 ;; (shift control meta left)
360 ;; (This is the same as the previous. when there's only one keystroke in
361 ;; the sequence, you can leave out the brackets, and that's normally
364 ;; [(control x) (shift button3)]
366 ;; (You can refer to mouse buttons just like keys -- apply modifiers,
367 ;; intermingle them in key sequences, etc. But there's only problem
368 ;; here, which is that with the mouse you don't just have one possible
369 ;; gesture, like with keys. You'd really like to control button-down,
370 ;; button-up, button-click (down and up without selecting anything),
371 ;; button drag, button double-click, etc. This is normally done by
372 ;; binding your key sequence to `mouse-track', and then putting hooks
373 ;; onto `mouse-track-click-hook', `mouse-track-drag-up-hook', etc. to
374 ;; customize the specific behavior.)
378 ;; (Ultimate reductionism -- no brackets, no parens. This is the form, in
379 ;; that, that the 'f1, 'f2, etc. took, which where in fact "long"
384 ;; (You cannot use '(control shift c) here. This applies whenever Shift +
385 ;; key translates to a single character. Note also that you can't use
386 ;; "\C-C" either; this refers to the non-shifted C-c, just like "\C-c"
390 ;; (Put a backslash in front of characters used in Lisp syntax.)
392 ;; Also, you can find out the name of a key using C-h c. WARNING:
393 ;; This does not report the correct name of the keys named `delete',
394 ;; `backspace', `return', `tab', `space', `escape', and `linefeed'!
395 ;; (More correct results can be achieved using
397 ;; ESC : (read-key-sequence "foo: ")
401 ;;;;;;;;;;;;;;;;;;;;;;;;
403 ;; Keystrokes to conveniently switch buffers.
405 ;; F6 is invaluable for flipping back and forth between two buffers
406 ;; you're working with.
408 (global-set-key 'f6 'switch-to-other-buffer) ;; M-C-l
409 (global-set-key '(meta n) 'switch-to-next-buffer-in-group)
410 (global-set-key '(meta p) 'switch-to-previous-buffer-in-group)
411 (global-set-key '(meta N) 'switch-to-next-buffer)
412 (global-set-key '(meta P) 'switch-to-previous-buffer)
414 ;; Define our own function to deal with the possibility that the newer
415 ;; stuff in the gutter code may not be present -- i.e. we're running
416 ;; an older XEmacs. Note that we avoid trying to "helpfully" define a
417 ;; function that is present in new versions of XEmacs, but not in
418 ;; older ones. That can very easily screw up code trying to determine
419 ;; what functionality is present using `fboundp' checks. See above,
420 ;; near `emacs-version>=', for a full discussion of this.
422 (defun Init-buffers-tab-omit (buf)
423 ;; a function specifying the buffers to omit from the buffers tab.
424 ;; This is passed a buffer and should return non-nil if the buffer
425 ;; should be omitted. If the standard buffers-tab functionality is
426 ;; there, we just call it to do things "right". Otherwise we just
427 ;; omit invisible buffers, snarfing the code from
428 ;; `buffers-menu-omit-invisible-buffers'.
429 (if (boundp 'buffers-tab-omit-function)
430 (funcall buffers-tab-omit-function buf)
431 (not (null (string-match "\\` " (buffer-name buf))))))
433 (defun switch-to-next-buffer (&optional n)
434 "Switch to the next-most-recent buffer.
435 This essentially rotates the buffer list forward.
436 N (interactively, the prefix arg) specifies how many times to rotate
437 forward, and defaults to 1. Buffers whose name begins with a space
438 \(i.e. \"invisible\" buffers) are ignored."
439 ;; Here is a different interactive spec. Look up the function
440 ;; `interactive' (i.e. `C-h f interactive') to understand how this
443 (dotimes (n (or n 1))
445 do (bury-buffer (car (buffer-list)))
446 while (Init-buffers-tab-omit (car (buffer-list))))
447 (switch-to-buffer (car (buffer-list)))))
449 (defun buffers-menu-omit-invisible-buffers (buf)
450 "For use as a value of `buffers-menu-omit-function'.
451 Omits normally invisible buffers (those whose name begins with a space)."
452 (not (null (string-match "\\` " (buffer-name buf)))))
454 (defvar Init-buffers-tab-grouping-regexp
455 '("^\\(gnus-\\|message-mode\\|mime/viewer-mode\\)"
456 "^\\(emacs-lisp-\\|lisp-\\)")
457 ;; If non-nil, a list of regular expressions for buffer grouping.
458 ;; Each regular expression is applied to the current major-mode symbol
459 ;; name and mode-name, if it matches then any other buffers that match
460 ;; the same regular expression be added to the current group. This is
461 ;; a copy of `buffers-tab-grouping-regexp'.
464 (defun Init-select-buffers-tab-buffers (buffer-to-select buf1)
465 ;; Specifies the buffers to select from the buffers tab. This is
466 ;; passed two buffers and should return non-nil if the second buffer
467 ;; should be selected. If the standard buffers-tab functionality is
468 ;; there, we just call it to do things "right". Otherwise, we group
469 ;; buffers by major mode and by `Init-buffers-tab-grouping-regexp'.
470 ;; [We've copied `select-buffers-tab-buffers-by-mode' and
471 ;; `buffers-tab-grouping-regexp'.]
472 (if (boundp 'buffers-tab-selection-function)
473 (funcall buffers-tab-selection-function buffer-to-select buf1)
474 (let ((mode1 (symbol-name (symbol-value-in-buffer 'major-mode buf1)))
475 (mode2 (symbol-name (symbol-value-in-buffer 'major-mode
477 (modenm1 (symbol-value-in-buffer 'mode-name buf1))
478 (modenm2 (symbol-value-in-buffer 'mode-name buffer-to-select)))
479 (cond ((or (eq mode1 mode2)
481 (and (string-match "^[^-]+-" mode1)
483 (concat "^" (regexp-quote
484 (substring mode1 0 (match-end 0))))
486 (and Init-buffers-tab-grouping-regexp
487 (find-if #'(lambda (x)
489 (and (string-match x mode1)
490 (string-match x mode2))
491 (and (string-match x modenm1)
492 (string-match x modenm2))))
493 Init-buffers-tab-grouping-regexp)))
497 (defun switch-to-previous-buffer (&optional n)
498 "Switch to the previously most-recent buffer.
499 This essentially rotates the buffer list backward.
500 N (interactively, the prefix arg) specifies how many times to rotate
501 backward, and defaults to 1. Buffers whose name begins with a space
502 \(i.e. \"invisible\" buffers) are ignored."
504 (dotimes (n (or n 1))
506 do (switch-to-buffer (car (last (buffer-list))))
507 while (Init-buffers-tab-omit (car (buffer-list))))))
509 (defun switch-to-next-buffer-in-group (&optional n)
510 "Switch to the next-most-recent buffer in the current group.
511 This essentially rotates the buffer list forward.
512 N (interactively, the prefix arg) specifies how many times to rotate
513 forward, and defaults to 1. Buffers whose name begins with a space
514 \(i.e. \"invisible\" buffers) are ignored."
516 (dotimes (n (or n 1))
517 (let ((curbuf (car (buffer-list))))
519 do (bury-buffer (car (buffer-list)))
520 while (or (Init-buffers-tab-omit (car (buffer-list)))
521 (not (Init-select-buffers-tab-buffers
522 curbuf (car (buffer-list)))))))
523 (switch-to-buffer (car (buffer-list)))))
525 (defun switch-to-previous-buffer-in-group (&optional n)
526 "Switch to the previously most-recent buffer in the current group.
527 This essentially rotates the buffer list backward.
528 N (interactively, the prefix arg) specifies how many times to rotate
529 backward, and defaults to 1. Buffers whose name begins with a space
530 \(i.e. \"invisible\" buffers) are ignored."
532 (dotimes (n (or n 1))
533 (let ((curbuf (car (buffer-list))))
535 do (switch-to-buffer (car (last (buffer-list))))
536 while (or (Init-buffers-tab-omit (car (buffer-list)))
537 (not (Init-select-buffers-tab-buffers
538 curbuf (car (buffer-list)))))))))
540 ;;;;;;;;;;;;;;;;;;;;;;;;
542 ;; Other text keystrokes.
544 ;; Make a keystroke to insert a literal TAB character. (`C-q TAB' is
545 ;; annoying because difficult to repeat.) Note that this does not work
546 ;; in TTY frames, where TAB and Shift-TAB are indistinguishable.
547 (define-key global-map '(shift tab) 'tab-to-tab-stop)
549 ;; Toggle auto-filling. Useful with text but annoying with code. You
550 ;; can manually fill with M-q.
551 (global-set-key '(meta f9) 'auto-fill-mode)
553 ;; You cannot say '(meta shift t) here -- see above.
554 (if (fboundp 'transpose-line-down)
555 (global-set-key '(meta T) 'transpose-line-down))
556 (if (fboundp 'transpose-line-up)
557 (global-set-key '(control T) 'transpose-line-up))
559 ;;;;;;;;;;;;;;;;;;;;;;;;
561 ;; Rearrange some inconvenient bindings.
563 ;; ESC ESC ESC is a useful command, but too long. ESC ESC would be
564 ;; much more logical, but interferes with Meta + keypad/arrow keys on
565 ;; TTY's. But most people only use window systems and no such problem
566 ;; exists there, so set up the more logical binding there.
568 ;; Note also the use of if vs. cond/when/unless/or/and to express
569 ;; conditional statements. The difference is purely stylistic.
571 (when (console-on-window-system-p)
572 (global-set-key '(meta escape) 'keyboard-escape-quit)
573 (define-key isearch-mode-map '(meta escape) 'isearch-cancel))
575 ;; The standard definition of C-z causes iconification on window
576 ;; systems, which is both useless and annoying. Instead, bind it to a
577 ;; useful command that's not on any keys. (This also makes a neat
578 ;; parallelism with M-z, which does zap-to-char.) Don't override the
579 ;; TTY binding, which does "Suspend". If you want this new binding on
580 ;; TTY's, and can train yourself to use C-x C-z to suspend, then
581 ;; remove or comment out the `when' statement. (Here's the proper way
582 ;; to comment out such a statement:
584 ;; ;(when (console-on-window-system-p)
585 ;; (global-set-key "\C-z" 'zap-up-to-char)
588 ;; To do this, I first moved the closing paren to a new line,
589 ;; reindented with TAB, then added the semicolons.)
591 (when (console-on-window-system-p)
592 (global-set-key "\C-z" 'zap-up-to-char))
594 ;; When not on a TTY, remove the binding of C-x C-c, which normally
595 ;; exits XEmacs. It's easy to hit this by mistake, and that can be
596 ;; annoying. You can always quit with the "Exit XEmacs" option on the
599 (when (console-on-window-system-p)
600 (global-set-key "\C-x\C-c" nil))
602 ;; Make C-k always delete the whole line, which is what most people want,
604 (setq kill-whole-line 'always)
605 ;; M-k does the old behavior (kill to end of line).
606 (global-set-key '(meta k) #'(lambda ()
608 (if (fboundp 'historical-kill-line)
609 (call-interactively #'historical-kill-line)
610 (let ((kill-whole-line nil))
611 (call-interactively #'kill-line)))))
612 ;; and Meta-Shift-K does what used to be on M-k, and should
613 ;; (hopefully) even work under TTY's.
614 (global-set-key '(meta K) 'kill-sentence)
616 ;; Make sure we get Windows-like shifted-motion key selection behavior
617 ;; on recent XEmacs versions.
618 (if (boundp 'shifted-motion-keys-select-region)
619 (setq shifted-motion-keys-select-region t)
620 ;; otherwise, try the pc-select package --
627 ;; The following commented-out code rearranges the keymap in an
628 ;; unconventional but extremely useful way for programmers. Parens
629 ;; and braces are both available without using the shift key (using
630 ;; the bracket keys and f11/f12, respectively). Brackets (much less
631 ;; used) are the shifted versions of the new paren keys (i.e. where
632 ;; the braces normally are).
634 ;; The idea for this comes from Jamie Zawinski.
636 ;; Also make a convenient keystroke for _, used constantly in C code.
638 ;; NOTE: you can (semi-) conveniently uncomment a region using
639 ;; C-u M-x comment-region, or the "Uncomment Region" menu item on the
640 ;; Lisp menu in new enough versions of XEmacs.
642 ;(keyboard-translate ?[ ?()
643 ;(keyboard-translate ?] ?))
644 ;(keyboard-translate ?{ ?[)
645 ;(keyboard-translate ?} ?])
646 ;;; We don't use `keyboard-translate' for these because it messes up
647 ;;; bindings for M-F9 and the like.
648 ;(define-key key-translation-map 'f11 "{")
649 ;(define-key key-translation-map 'f12 "}")
650 ;(define-key key-translation-map 'f9 "_")
653 ;;;;;;;;;;;;;;;;;;;;;;;;
655 ;; Useful programming-related keystrokes.
657 (defun describe-foo-at-point ()
658 "Show the documentation of the Elisp function and variable near point.
661 -- for a function name where point is
662 -- for a variable name where point is
663 -- for a surrounding function call
667 ;; sigh, function-at-point is too clever. we want only the first half.
668 (cond ((setq sym (ignore-errors
669 (with-syntax-table emacs-lisp-mode-syntax-table
671 (or (not (zerop (skip-syntax-backward "_w")))
672 (eq (char-syntax (char-after (point))) ?w)
673 (eq (char-syntax (char-after (point))) ?_)
675 (skip-chars-forward "`'")
676 (let ((obj (read (current-buffer))))
677 (and (symbolp obj) (fboundp obj) obj))))))
678 (describe-function sym))
679 ((setq sym (variable-at-point)) (describe-variable sym))
680 ;; now let it operate fully -- i.e. also check the
681 ;; surrounding sexp for a function call.
682 ((setq sym (function-at-point)) (describe-function sym)))))
684 (global-set-key '(shift f4) 'next-error) ;; C-x `
685 (global-set-key '(control f4) 'previous-error)
686 (global-set-key '(shift f5) 'find-library)
687 (global-set-key '(control f5) 'find-function)
688 (global-set-key '(meta f5) 'find-variable)
689 (global-set-key '(shift f11) 'describe-foo-at-point)
690 (global-set-key '(control f11) 'eval-last-sexp)
691 ;; Edebug is a source-level debugger for Emacs Lisp programs. Put
692 ;; the cursor at the end of a function definition and "instrument" it
693 ;; with this command; then, you can single step through it the next
695 (global-set-key '(meta f11) 'edebug-defun)
696 (global-set-key '(meta f12) 'add-change-log-entry)
698 ;; This nicely parallels M-*, which pops the tag stack. See below for
699 ;; how to set up tags.
700 (global-set-key '(control *) 'find-tag-at-point)
702 ;; Define a function to conveniently determine where time is being
703 ;; spent when executing commands or Lisp code.
704 (defun toggle-profiling ()
705 "Start profiling, or stop it and print results.
706 This lets you figure out where time is being spent when executing Lisp code."
708 (if (profiling-active-p)
711 (message "...Finished profiling")
713 (message "Profiling...")
714 (clear-profiling-info)
717 ;; Note that sequences of C-c plus a letter are specifically
718 ;; reserved for users and should never be bound by any packages.
720 (global-set-key "\C-cp" 'toggle-profiling)
722 ;; LISPM bindings of Control-Shift-C and Control-Shift-E.
723 ;; See comment above about bindings like this.
724 (define-key emacs-lisp-mode-map '(control C) 'compile-defun)
725 (define-key emacs-lisp-mode-map '(control E) 'eval-defun)
727 ;;;;;;;;;;;;;;;;;;;;;;;;
731 ;; The numeric keypad as a whole is underused, and it's a good source
732 ;; of keys to bind to commands. Here we add some useful bindings.
733 ;; Because this is a sample file and I want to avoid unpleasant
734 ;; surprises for novices, I don't actually bind the shared
735 ;; numeric/cursor-motion keys because
737 ;; (a) someone keypads don't have separate motion keys (e.g. laptops?), and
738 ;; (b) TTY's and some X servers might not distinguish the regular and
739 ;; numeric-keypad motion keys.
741 ;; `kill-current-buffer' (defined below) deletes the current
742 ;; buffer. (Don't worry, you will be prompted to save if it's
743 ;; modified.) By repeatedly pressing keypad-minus, you can
744 ;; conveniently reduce the number of open buffers to a manageable size
745 ;; after you've opened a whole bunch of files and finished working on
746 ;; them. Shift plus keypad-minus kills both the current buffer and
747 ;; its window, and Control plus keypad-minus kills just the current
750 (global-set-key 'kp-subtract 'kill-current-buffer)
751 (global-set-key '(shift kp-subtract) 'kill-current-buffer-and-window)
752 (global-set-key '(control kp-subtract) 'delete-window)
753 ;; Ugh, modes that use `suppress-keymap' and are dumped with XEmacs will
754 ;; need their own definition. There is no easy way to fix this.
755 (define-key help-mode-map 'kp-subtract 'kill-current-buffer)
756 (define-key help-mode-map '(shift kp-subtract)
757 'kill-current-buffer-and-window)
758 (define-key list-mode-map 'kp-subtract 'kill-current-buffer)
759 (define-key list-mode-map '(shift kp-subtract)
760 'kill-current-buffer-and-window)
762 (defun kill-current-buffer ()
763 "Kill the current buffer (prompting if it is modified)."
765 (kill-buffer (current-buffer)))
767 (defun kill-current-buffer-and-window ()
768 "Kill the current buffer (prompting if it is modified) and its window."
770 (kill-buffer (current-buffer))
773 (defvar grep-all-files-history nil)
775 (defvar grep-all-files-omitted-expressions
776 '("*~" "#*" ".#*" ",*" "*.elc" "*.obj" "*.o" "*.exe" "*.dll" "*.lib" "*.a"
777 "*.dvi" "*.class" "*.bin")
778 "List of expressions matching files to be omitted in `grep-all-files-...'.
779 Each entry should be a simple name or a shell wildcard expression.")
781 (defvar grep-all-files-omitted-directories '("CVS" "RCS" "SCCS")
782 "List of directories not to recurse into in `grep-all-files-...'.
783 Each entry should be a simple name or a shell wildcard expression.")
785 (defun construct-grep-all-files-command (find-segment grep-segment)
787 (mapconcat #'(lambda (wildcard)
788 (concat "-name '" wildcard "' -or "))
789 grep-all-files-omitted-expressions
791 (cond ((eq grep-find-use-xargs 'gnu)
792 (format "find . %s %s -type f -print0 | xargs -0 -e %s"
793 find-segment omit-annoying grep-segment))
795 (format "find . %s %s -type f -print | xargs %s"
796 find-segment omit-annoying grep-segment))
798 (format "find . %s %s -type f -exec %s {} /dev/null \\;"
799 find-segment omit-annoying grep-segment)))))
801 (defun grep-all-files-in-current-directory (command)
802 "Run `grep' in all non-annoying files in the current directory.
803 `Non-annoying' excludes backup files, autosave files, CVS merge files, etc.
804 More specifically, this is controlled by `grep-all-files-omitted-expressions'.
806 This function does not recurse into subdirectories. If you want this,
807 use \\[grep-all-files-in-current-directory-and-below]."
811 (list (read-shell-command "Run grep (like this): "
812 grep-command 'grep-all-files-history))))
814 (grep (construct-grep-all-files-command
815 "-name . -or -type d -prune -or" command)))
817 (defun grep-all-files-in-current-directory-and-below ()
818 "Run `grep' in all non-annoying files in the current directory and below.
819 `Non-annoying' excludes backup files, autosave files, CVS merge files, etc.
820 More specifically, this is controlled by `grep-all-files-omitted-expressions'.
822 This function recurses into subdirectories. If you do not want this,
823 use \\[grep-all-files-in-current-directory]."
827 (list (read-shell-command "Run grep (like this): "
828 grep-command 'grep-all-files-history))))
830 (grep (construct-grep-all-files-command
831 ;; prune all specified directories.
832 (mapconcat #'(lambda (wildcard)
833 (concat "-name '" wildcard "' -prune -or "))
834 grep-all-files-omitted-directories
838 (defun clear-select ()
839 "Repeatedly select ever larger balanced expressions around the cursor.
840 Once you have such an expression marked, you can expand to the end of
841 the following expression with \\[mark-sexp] and to the beginning of the
842 previous with \\[backward-sexp]."
843 (interactive "_") ;this means "preserve the active region after this command"
845 (let ((end (save-excursion (forward-sexp) (point))))
846 (push-mark end nil t)))
848 ;; #### no kp-divide because it doesn't (currently) work on MS Windows
849 ;; -- always reports as /. #### this should be fixable.
850 (global-set-key 'kp-add 'query-replace)
851 (global-set-key '(shift kp-add) 'query-replace-regexp)
852 (global-set-key '(control kp-add) 'grep-all-files-in-current-directory)
853 (global-set-key '(meta kp-add) 'grep-all-files-in-current-directory-and-below)
854 (global-set-key 'clear 'clear-select)
855 ;; Note that you can use a "lambda" expression (an anonymous function)
856 ;; in place of a function name. This function would be called
857 ;; `pop-local-mark' and lets you repeatedly cycle back through recent
858 ;; marks (marks are set whenever you begin a selection, begin a
859 ;; successful search, are about to jump to the beginning or end of the
861 (global-set-key 'kp-enter (lambda () (interactive) (set-mark-command t)))
862 (global-set-key '(shift kp-enter) 'repeat-complex-command)
863 (global-set-key 'pause 'repeat-complex-command) ;; useful on Windows-style kbds
864 (global-set-key '(control kp-enter) 'eval-expression)
866 ;;;;;;;;;;;;;;;;;;;;;;;;
870 ;; If you want button2 to insert the selected text
871 ;; at point (where the text cursor is), instead of at the
872 ;; position clicked, uncomment the following:
874 ;(setq mouse-yank-at-point t)
876 ;; If you like the FSF Emacs binding of button3 (single-click
877 ;; extends the selection, double-click kills the selection),
878 ;; uncomment the following:
880 ;(define-key global-map 'button3 'mouse-track-adjust)
882 ;(add-hook 'mouse-track-click-hook
883 ; (lambda (event count)
884 ; (if (or (/= (event-button event) 3)
886 ; nil ;; do the normal operation
887 ; (kill-region (point) (mark))
888 ; t ;; don't do the normal operations.
891 ;; Uncomment this to enable "sticky modifier keys". With sticky
892 ;; modifier keys enabled, you can press and release a modifier key
893 ;; before pressing the key to be modified, like how the ESC key works
894 ;; always. If you hold the modifier key down, however, you still get
895 ;; the standard behavior. I personally think this is the best thing
896 ;; since sliced bread (and a *major* win when it comes to reducing
897 ;; Emacs pinky), but it's disorienting at first so I'm not enabling it
900 ;(setq modifier-keys-are-sticky t)
902 ;; Enable the command `narrow-to-region' ("C-x n n"). It's a useful
903 ;; command, but possibly confusing to a new user, so it's disabled by
905 (put 'narrow-to-region 'disabled nil)
907 ;; Enable obvious hyperlink following with button1.
908 (setq Info-button1-follows-hyperlink t)
911 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
912 ;; Change Some Basic Behaviors ;;
913 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
915 ;; Change the values of some variables.
916 ;; (t means true; nil means false.)
918 ;; Use C-h v or `Help->Commands, Variables, Keys->Describe Variable...'
919 ;; to find out what these variables mean.
921 find-file-compare-truenames t
922 minibuffer-max-depth nil
925 ;; When running ispell, consider all 1-3 character words as correct.
926 (setq ispell-extra-args '("-W" "3"))
928 ;;; pending-delete-mode causes typed text to replace a selection,
929 ;;; rather than append -- standard behavior under all window systems
932 (pending-delete-mode 1)
934 ;;; enable region selection with shift+arrows (on by default in 21.5
936 (setq shifted-motion-keys-select-region t)
938 ;;; NOTE: In this context, `windows-nt' actually refers to all MS
939 ;;; Windows operating systems!
940 (when (eq system-type 'windows-nt)
941 ;; Get mail working under Windows.
942 (setq send-mail-function 'smtpmail-send-it)
943 (setq smtpmail-debug-info t)
944 ;; Substitute your info here.
945 ;(setq user-mail-address "ben@xemacs.org")
946 ;(setq user-full-name "Ben Wing")
947 ;(setq smtpmail-smtp-server "pop.tcsn.uswest.net")
949 ;; Make Meta+accelerator traverse to the menu in new enough XEmacs
950 ;; versions. Note that this only overrides Meta bindings that would
951 ;; actually invoke a menu, and the most common commands that are
952 ;; overridden have preferred alternative bindings using the arrow
953 ;; keys. You can always access the overridden ones using
954 ;; Shift+Meta+Key. (Note that "Alt" and "Meta" normally refer to the
955 ;; same key, except on some Sun keyboards [where "Meta" is actually
956 ;; labelled with a diamond] or if you have explicitly made them
957 ;; different under X Windows using `xmodmap'.)
959 ;; More specifically, the following bindings are overridden:
961 ;; M-f (use C-right or Sh-M-f instead)
962 ;; M-e (use M-C-right or Sh-M-e instead)
963 ;; M-v (use Prior aka PgUp or Sh-M-v instead)
964 ;; M-m (use Sh-M-m instead)
965 ;; M-t (use Sh-M-t instead)
966 ;; M-o (normally undefined)
967 ;; M-b (use C-left or Sh-M-b instead)
968 ;; M-h (use M-e h or Sh-M-h instead)
969 ;; in Lisp mode, M-l (use Sh-M-l instead)
970 ;; in C mode, M-c (use Sh-M-c instead)
972 (setq menu-accelerator-enabled 'menu-force)
974 ;; Make Cygwin `make' work inside a shell buffer.
975 (setenv "MAKE_MODE" "UNIX"))
977 ;; This shows how to set up the XEmacs side of tags. (To create the
978 ;; TAGS table, use the `etags' program found in the XEmacs bin
979 ;; directory. Run it in the root directory of your source tree and
980 ;; specify all source and include files on the command line.)
981 ;(setq tag-table-alist
983 ; ;; Everywhere in the /src/xemacs/gui/ source tree will use the TAGS
984 ; ;; file in /src/xemacs/gui/.
985 ; ("/src/xemacs/gui/" . "/src/xemacs/gui/")
986 ; ;; Everywhere in the /src/xemacs/mule/ source tree will use the TAGS
987 ; ;; file in /src/xemacs/mule/.
988 ; ("/src/xemacs/mule/" . "/src/xemacs/mule/")
990 ; ("/src/xemacs/fixup/" . "/src/xemacs/fixup/")
991 ; ("/src/emacs/emacs-20.6/" . "/src/emacs/emacs-20.6/")
992 ; ("/src/xemacs/latest/" . "/src/xemacs/latest/")
993 ; ;; Everywhere else will use the TAGS file in
994 ; ;; /src/xemacs/fixup/.
995 ; ("" . "/src/xemacs/fixup/")
999 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1000 ;; Change Some Aspects of GUI Appearance ;;
1001 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1003 ;; Changes the text in the window title bar, to switch to MS Windows
1004 ;; format (filename goes first, for best identification in icons) and
1005 ;; add the version and full executable path. (However, it is not
1006 ;; changed unless it currently has the default value, to avoid
1007 ;; interfering with a -wn command line argument I may have started
1010 (if (or (equal frame-title-format "%S: %b")
1011 (equal frame-title-format "%b - XEmacs"))
1012 (setq frame-title-format
1013 (concat "%b - XEmacs "
1014 (progn (string-match "\\(.*?\\)\\( XEmacs Lucid\\)?$"
1016 (match-string 1 emacs-version))
1017 " [" invocation-directory invocation-name "]")))
1019 ;; Load some nifty sounds that will replace the default beep.
1021 ;; (Note that sampled sounds only work if XEmacs was compiled with
1022 ;; sound support and we're running on MS Windows, on a machine which
1023 ;; has a NetAudio or ESD server, or on the console of a Linux, Sparc,
1024 ;; HP, or SGI machine. Otherwise, you just get the standard beep.)
1026 (cond ((or (and (getenv "DISPLAY")
1027 (string-match ":0" (getenv "DISPLAY")))
1028 (and (eq (console-type) 'mswindows)
1029 (device-sound-enabled-p)))
1030 (load-default-sounds)
1031 ;; On Windows, at least, the sound "quiet-beep", which is normally
1032 ;; given the symbolic name `quiet' and is used for Quit and such,
1033 ;; is just totally disgusting. So make this name correspond to a
1034 ;; more innocuous sound.
1035 (load-sound-file "drum-beep" 'quiet 80))
1037 (setq bell-volume 40)
1039 (append sound-alist '((no-completion :pitch 500))))
1042 ;; Change the continuation glyph face so it stands out more
1043 (make-face-bold (glyph-face continuation-glyph))
1045 ;; Change the pointer used during garbage collection.
1047 ;; Note that this pointer image is rather large as pointers go,
1048 ;; and so it won't work on some X servers (such as the MIT
1049 ;; R5 Sun server) because servers may have lamentably small
1050 ;; upper limits on pointer size.
1051 ;;(if (featurep 'xpm)
1052 ;; (set-glyph-image gc-pointer-glyph
1053 ;; (expand-file-name "trash.xpm" data-directory)))
1055 ;; Here's another way to do that: it first tries to load the
1056 ;; pointer once and traps the error, just to see if it's
1057 ;; possible to load that pointer on this system; if it is,
1058 ;; then it sets gc-pointer-glyph, because we know that
1059 ;; will work. Otherwise, it doesn't change that variable
1060 ;; because we know it will just cause some error messages.
1062 (let ((file (expand-file-name "recycle.xpm" data-directory)))
1063 (if (condition-case nil
1064 ;; check to make sure we can use the pointer.
1065 (make-image-instance file nil
1067 (error nil)) ; returns nil if an error occurred.
1068 (set-glyph-image gc-pointer-glyph file))))
1070 ;(when (featurep 'menubar)
1071 ; ;; Add `dired' to the File menu
1072 ; (add-menu-button '("File") ["Edit Directory" dired])
1074 ; ;; Here's a way to add scrollbar-like buttons to the menubar
1075 ; (add-menu-button nil ["Top" beginning-of-buffer])
1076 ; (add-menu-button nil ["<<<" scroll-down])
1077 ; (add-menu-button nil [" . " recenter])
1078 ; (add-menu-button nil [">>>" scroll-up])
1079 ; (add-menu-button nil ["Bot" end-of-buffer]))
1081 ;; Here's a cute hack that shows how to programmatically change some
1082 ;; text colors. It changes the background color of the window if it's
1083 ;; not on the local machine, or if it's running as root:
1085 ;; local emacs background: whitesmoke [i.e. the default color]
1086 ;; remote emacs background: palegreen1
1087 ;; root emacs background: coral2
1089 ;; Uncomment to enable.
1092 ; ((and running-xemacs
1093 ; (console-on-window-system-p)
1094 ; ;; this does not make much sense on Windows.
1095 ; (not (eq system-type 'windows-nt)))
1096 ; (let* ((root-p (eq 0 (user-uid)))
1097 ; (dpy (or (getenv "DISPLAY") ""))
1099 ; (or (string-match "^\\(\\|unix\\|localhost\\):" dpy)
1100 ; (let ((s (system-name)))
1101 ; (if (string-match "\\.\\(netscape\\|mcom\\)\\.com" s)
1102 ; (setq s (substring s 0 (match-beginning 0))))
1103 ; (string-match (concat "^" (regexp-quote s)) dpy)))))
1104 ; (bg (cond (root-p "coral2")
1105 ; (remote-p "palegreen1")
1108 ; (let ((def (color-name (face-background 'default)))
1109 ; (faces (face-list)))
1111 ; (let ((obg (face-background (car faces))))
1112 ; (if (and obg (equal def (color-name obg)))
1113 ; (set-face-background (car faces) bg)))
1114 ; (setq faces (cdr faces)))))))))
1117 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1118 ;; Changing the Modeline ;;
1119 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1121 ;; Enable line numbers and column numbers. This is done in C code now
1122 ;; and is very fast.
1123 (line-number-mode 1)
1124 (column-number-mode 1)
1126 ;; Rearrange the modeline so that everything is to the left of the
1127 ;; long list of minor modes, which is relatively unimportant but takes
1128 ;; up so much room that anything to the right is obliterated.
1134 (if (boundp 'modeline-multibyte-status) 'modeline-multibyte-status "")
1135 (cons modeline-modified-extent 'modeline-modified)
1136 (cons modeline-buffer-id-extent
1137 (list (cons modeline-buffer-id-left-extent
1139 (list 'line-number-mode "L%l ")
1140 (list 'column-number-mode "C%c ")
1142 (cons modeline-buffer-id-right-extent "%17b")))
1146 (cons modeline-minor-mode-extent
1147 (list "" 'mode-name 'minor-mode-alist))
1148 (cons modeline-narrowed-extent "%n")
1154 ;; Get rid of modeline information taking up too much space -- in
1155 ;; particular, minor modes that are always enabled.
1156 (setq pending-delete-modeline-string "")
1157 (setq filladapt-mode-line-string "")
1158 ;; lazy-lock doesn't have a variable for its modeline name, so we have
1159 ;; to do a bit of surgery.
1160 (and (assoc 'lazy-lock-mode minor-mode-alist)
1161 (setcdr (cdr (cadr (assoc 'lazy-lock-mode minor-mode-alist))) ""))
1165 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1166 ;; Customization of Specific Packages ;;
1167 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1170 ;;; ********************
1171 ;;; Load gnuserv, which will allow you to connect to XEmacs sessions
1172 ;;; using `gnuclient'.
1174 ;; If you never run more than one XEmacs at a time, you might want to
1175 ;; always start gnuserv. Otherwise it is preferable to specify
1176 ;; `-f gnuserv-start' on the command line to one of the XEmacsen.
1180 ;;; ********************
1181 ;;; Load efs, which uses the FTP protocol as a pseudo-filesystem.
1182 ;;; When this is loaded, the pathname syntax /user@host:/remote/path
1183 ;;; refers to files accessible through ftp.
1186 ;; compatible ange-ftp/efs initialization derived from code
1187 ;; from John Turner <turner@lanl.gov>
1189 ;; The environment variable EMAIL_ADDRESS is used as the password
1190 ;; for access to anonymous ftp sites, if it is set. If not, one is
1191 ;; constructed using the environment variables USER and DOMAINNAME
1192 ;; (e.g. turner@lanl.gov), if set.
1198 (setq efs-default-user (getenv "USER")))
1199 (if (getenv "EMAIL_ADDRESS")
1200 (setq efs-generate-anonymous-password (getenv "EMAIL_ADDRESS"))
1201 (if (and (getenv "USER")
1202 (getenv "DOMAINNAME"))
1203 (setq efs-generate-anonymous-password
1204 (concat (getenv "USER")"@"(getenv "DOMAINNAME")))))
1205 (setq efs-auto-save 1))
1209 (setq ange-ftp-default-user (getenv "USER")))
1210 (if (getenv "EMAIL_ADDRESS")
1211 (setq ange-ftp-generate-anonymous-password (getenv "EMAIL_ADDRESS"))
1212 (if (and (getenv "USER")
1213 (getenv "DOMAINNAME"))
1214 (setq ange-ftp-generate-anonymous-password
1215 (concat (getenv "USER")"@"(getenv "DOMAINNAME")))))
1216 (setq ange-ftp-auto-save 1)
1220 ;;; ********************
1221 ;;; Load the default-dir.el package which installs fancy handling of
1222 ;;; the initial contents in the minibuffer when reading file names.
1224 ;(condition-case nil
1225 ; (require 'default-dir)
1229 ;;; ********************
1230 ;;; Put all of your autosave files in one place, instead of scattering
1231 ;;; them around the file system. This has many advantages -- e.g. it
1232 ;;; will eliminate slowdowns caused by editing files on a slow NFS
1233 ;;; server. (*Provided* that your home directory is local or on a
1234 ;;; fast server! If not, pick a value for `auto-save-directory' that
1235 ;;; is fast fast fast!)
1237 ;;; Unfortunately, the code that implements this (auto-save.el) is
1238 ;;; broken on Windows in 21.4 and earlier.
1239 (unless (and (eq system-type 'windows-nt)
1240 (not (emacs-version>= 21 5)))
1241 (setq auto-save-directory (expand-file-name "~/.autosave/")
1242 auto-save-directory-fallback auto-save-directory
1243 auto-save-hash-p nil
1245 efs-auto-save-remotely nil
1246 ;; now that we have auto-save-timeout, let's crank this up
1247 ;; for better interactive response.
1248 auto-save-interval 2000
1250 ;; We load this afterwards because it checks to make sure the
1251 ;; auto-save-directory exists (creating it if not) when it's loaded.
1252 (require 'auto-save)
1256 ;;; ********************
1257 ;;; cc-mode (the mode you're in when editing C, C++, and Objective C files)
1259 ;; Tell cc-mode not to check for old-style (K&R) function declarations.
1260 ;; This speeds up indenting a lot.
1261 (setq c-recognize-knr-p nil)
1263 ;; Change the indentation amount to 4 spaces instead of 2.
1264 ;; You have to do it in this complicated way because of the
1265 ;; strange way the cc-mode initializes the value of `c-basic-offset'.
1266 ;; (add-hook 'c-mode-hook (lambda () (setq c-basic-offset 4)))
1269 ;;; ********************
1270 ;;; Load a partial-completion mechanism, which makes minibuffer completion
1271 ;;; search multiple words instead of just prefixes; for example, the command
1272 ;;; `M-x byte-compile-and-load-file RET' can be abbreviated as `M-x b-c-a RET'
1273 ;;; because there are no other commands whose first three words begin with
1274 ;;; the letters `b', `c', and `a' respectively.
1276 (load-library "completer")
1279 ;;; ********************
1280 ;;; Load crypt, which is a package for automatically decoding and reencoding
1281 ;;; files by various methods - for example, you can visit a .Z or .gz file,
1282 ;;; edit it, and have it automatically re-compressed when you save it again.
1284 (setq crypt-encryption-type 'pgp ; default encryption mechanism
1285 crypt-confirm-password t ; make sure new passwords are correct
1286 ;crypt-never-ever-decrypt t ; if you don't encrypt anything, set this to
1287 ; tell it not to assume that "binary" files
1288 ; are encrypted and require a password.
1293 ;;; ********************
1294 ;;; Filladapt is a syntax-highlighting package. When it is enabled it
1295 ;;; makes filling (e.g. using M-q) much much smarter about paragraphs
1296 ;;; that are indented and/or are set off with semicolons, dashes, etc.
1298 (require 'filladapt)
1299 (setq-default filladapt-mode t)
1300 (add-hook 'c-mode-hook 'turn-off-filladapt-mode)
1303 ;;; ********************
1304 ;;; Font-Lock is a syntax-highlighting package. When it is enabled and you
1305 ;;; are editing a program, different parts of your program will appear in
1306 ;;; different fonts or colors. For example, with the code below, comments
1307 ;;; appear in red italics, function names in function definitions appear in
1308 ;;; blue bold, etc. The code below will cause font-lock to automatically be
1309 ;;; enabled when you edit C, C++, Emacs-Lisp, and many other kinds of
1312 ;;; The "Options" menu has some commands for controlling this as well.
1314 (cond (running-xemacs
1316 ;; The commented-out code below is an example of setting up custom
1317 ;; font-lock colors.
1319 ; ;; If you want the default colors, you could do this:
1320 ; ;; (setq font-lock-use-default-fonts nil)
1321 ; ;; (setq font-lock-use-default-colors t)
1322 ; ;; but I want to specify my own colors, so I turn off all
1323 ; ;; default values.
1324 ; (setq font-lock-use-default-fonts nil)
1325 ; (setq font-lock-use-default-colors nil)
1327 (require 'font-lock)
1329 ; ;; Mess around with the faces a bit. Note that you have
1330 ; ;; to change the font-lock-use-default-* variables *before*
1331 ; ;; loading font-lock, and wait till *after* loading font-lock
1332 ; ;; to customize the faces.
1334 ; ;; string face is green
1335 ; (set-face-foreground 'font-lock-string-face "forest green")
1337 ; ;; comments are italic and red; doc strings are italic
1338 ; (set-face-font 'font-lock-comment-face [italic])
1339 ; ;; Underlining comments looks terrible on tty's
1340 ; (set-face-underline-p 'font-lock-comment-face nil 'global 'tty)
1341 ; (set-face-highlight-p 'font-lock-comment-face t 'global 'tty)
1342 ; (copy-face 'font-lock-comment-face 'font-lock-doc-string-face)
1343 ; (set-face-foreground 'font-lock-comment-face "red")
1345 ; ;; function names are bold and blue
1346 ; (set-face-font 'font-lock-function-name-face [bold])
1347 ; (set-face-foreground 'font-lock-function-name-face "blue")
1350 ; (set-face-font 'font-lock-preprocessor-face [bold])
1351 ; (set-face-font 'font-lock-type-face [italic])
1352 ; (set-face-font 'font-lock-keyword-face [bold])
1356 ;;; ********************
1357 ;;; lazy-lock is a package which speeds up the highlighting of files
1358 ;;; by doing it "on-the-fly" -- only the visible portion of the
1359 ;;; buffer is fontified. The results may not always be quite as
1360 ;;; accurate as using full font-lock or fast-lock, but it's *much*
1361 ;;; faster. No more annoying pauses when you load files.
1363 (add-hook 'font-lock-mode-hook 'turn-on-lazy-lock)
1364 ;; I personally don't like "stealth mode" (where lazy-lock starts
1365 ;; fontifying in the background if you're idle for 30 seconds)
1366 ;; because it takes too long to wake up again on my piddly Sparc 1+.
1367 (setq lazy-lock-stealth-time nil)
1370 ;;; ********************
1371 ;;; func-menu is a package that scans your source file for function
1372 ;;; definitions and makes a menubar entry that lets you jump to any
1373 ;;; particular function definition by selecting it from the menu. The
1374 ;;; following code turns this on for all of the recognized languages.
1375 ;;; Scanning the buffer takes some time, but not much.
1377 ;;; Send bug reports, enhancements etc to:
1378 ;;; David Hughes <ukchugd@ukpmr.cs.philips.nl>
1380 (cond (running-xemacs
1381 (require 'func-menu)
1382 (global-set-key '(shift f12) 'function-menu)
1383 (add-hook 'find-file-hooks 'fume-add-menubar-entry)
1384 (global-set-key "\C-cl" 'fume-list-functions)
1385 (global-set-key "\C-cg" 'fume-prompt-function-goto)
1387 ;; The Hyperbole information manager package uses (shift button2) and
1388 ;; (shift button3) to provide context-sensitive mouse keys. If you
1389 ;; use this next binding, it will conflict with Hyperbole's setup.
1390 ;; Choose another mouse key if you use Hyperbole.
1391 (global-set-key '(shift button3) 'mouse-function-menu)
1393 ;; For descriptions of the following user-customizable variables,
1394 ;; type C-h v <variable>
1395 (setq fume-max-items 25
1396 fume-fn-window-position 3
1397 fume-auto-position-popup t
1398 fume-display-in-modeline-p t
1399 fume-menubar-menu-name
1400 (if (fboundp 'submenu-generate-accelerator-spec)
1401 "Function%_s" "Functions")
1402 fume-buffer-name "*Function List*"
1403 fume-no-prompt-on-valid-default nil)
1407 ;;; ********************
1408 ;;; MH is a mail-reading system from the Rand Corporation that relies on a
1409 ;;; number of external filter programs (which do not come with emacs.)
1410 ;;; Emacs provides a nice front-end onto MH, called "mh-e".
1412 ;; Bindings that let you send or read mail using MH
1413 ;(global-set-key "\C-xm" 'mh-smail)
1414 ;(global-set-key "\C-x4m" 'mh-smail-other-window)
1415 ;(global-set-key "\C-cr" 'mh-rmail)
1417 ;; Customization of MH behavior.
1418 (setq mh-delete-yanked-msg-window t)
1419 (setq mh-yank-from-start-of-msg 'body)
1420 (setq mh-summary-height 11)
1422 ;; Use lines like the following if your version of MH
1423 ;; is in a special place.
1424 ;(setq mh-progs "/usr/dist/pkgs/mh/bin.svr4/")
1425 ;(setq mh-lib "/usr/dist/pkgs/mh/lib.svr4/")
1428 ;;; ********************
1429 ;;; resize-minibuffer-mode makes the minibuffer automatically
1430 ;;; resize as necessary when it's too big to hold its contents.
1432 (autoload 'resize-minibuffer-mode "rsz-minibuf" nil t)
1433 (resize-minibuffer-mode)
1434 (setq resize-minibuffer-window-exactly nil)
1437 ;;; ********************
1438 ;;; scroll-in-place is a package that keeps the cursor on the same line (and in the same column) when scrolling by a page using PgUp/PgDn.
1440 (require 'scroll-in-place)
1441 (turn-on-scroll-in-place)
1444 ;;; ********************
1445 ;;; W3 is a browser for the World Wide Web, and takes advantage of the very
1446 ;;; latest redisplay features in XEmacs. You can access it simply by typing
1447 ;;; 'M-x w3'; however, if you're unlucky enough to be on a machine that is
1448 ;;; behind a firewall, you will have to do something like this first:
1450 ;(setq w3-use-telnet t
1452 ; ;; If the Telnet program you use to access the outside world is
1453 ; ;; not called "telnet", specify its name like this.
1454 ; w3-telnet-prog "itelnet"
1456 ; ;; If your Telnet program adds lines of junk at the beginning
1457 ; ;; of the session, specify the number of lines here.
1458 ; w3-telnet-header-length 4