|
462
|
1 ;; -*- Mode: Emacs-Lisp -*-
|
|
|
2
|
|
|
3 ;; Copyright (C) 2000, 2001 Ben Wing.
|
|
|
4
|
|
|
5 ;; Author: Mostly Ben Wing <ben@xemacs.org>
|
|
|
6 ;; Maintainer: XEmacs Development Team
|
|
|
7 ;; Keywords: sample, initialization
|
|
|
8
|
|
|
9 ;; This file is part of XEmacs.
|
|
|
10
|
|
|
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)
|
|
|
14 ;; any later version.
|
|
|
15
|
|
|
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.
|
|
|
20
|
|
|
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.
|
|
|
25
|
|
|
26 ;; #### to do:
|
|
|
27 ;; -- #### figure out how init.el and custom.el interact and put
|
|
|
28 ;; documentation about it here. (perhaps it already exists
|
|
|
29 ;; elsewhere?)
|
|
|
30
|
|
|
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
|
|
|
37 ;;;
|
|
|
38 ;;; ESC : (expand-file-name "~")
|
|
|
39 ;;;
|
|
|
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).
|
|
|
46
|
|
|
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
|
|
|
49 ;;;
|
|
|
50 ;;; M-x load-file RET ~/.xemacs/init.el RET
|
|
|
51
|
|
|
52 ;;; The language that this file (and most other XEmacs init files) is
|
|
|
53 ;;; written in is called "XEmacs Lisp" or more commonly "Elisp".
|
|
|
54
|
|
|
55 ;;; There are many sources of further information:
|
|
|
56
|
|
|
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.)
|
|
|
66
|
|
|
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
|
|
|
69 ;;; the Help menu)
|
|
|
70
|
|
|
71 ;;; -- the XEmacs Lisp Reference Manual, containing detailed
|
|
|
72 ;;; documentation on Elisp. (Access using Info, just like for the
|
|
|
73 ;;; XEmacs User's Manual.)
|
|
|
74
|
|
|
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.)
|
|
|
92
|
|
|
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.)
|
|
|
97
|
|
|
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)
|
|
|
101
|
|
|
102 ;;; -- the XEmacs web site, www.xemacs.org.
|
|
|
103
|
|
|
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
|
|
|
110 ;;; www.xemacs.org.)
|
|
|
111
|
|
|
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.
|
|
|
116
|
|
|
117 ;;; -- the XEmacs internals manual, for those interested in working on
|
|
|
118 ;;; the XEmacs C code. (Available through Info.)
|
|
|
119
|
|
|
120 ;;; -- `Help->About XEmacs' to find out who the maintainers are.
|
|
|
121
|
|
|
122
|
|
|
123 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
124 ;; Basic Customization ;;
|
|
|
125 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
126
|
|
|
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.
|
|
|
130
|
|
|
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
|
|
|
136 ;; XEmacs.)
|
|
|
137
|
|
|
138 (or (boundp 'running-xemacs)
|
|
|
139 (defvar running-xemacs (string-match "XEmacs\\|Lucid" emacs-version)))
|
|
|
140
|
|
|
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.)
|
|
|
148 ;;
|
|
|
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.)
|
|
|
166 ;;
|
|
|
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).
|
|
|
181
|
|
|
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,
|
|
|
185 and PATCH numbers.
|
|
|
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)
|
|
|
191 ((null minor))
|
|
|
192 ((> emacs-minor-version minor))
|
|
|
193 ((< emacs-minor-version minor) nil)
|
|
|
194 ((null patch))
|
|
|
195 ((>= emacs-patch patch))))))
|
|
|
196
|
|
|
197 ;; 19.13 was released ages ago (Sep. 1995), and lots of graphic and
|
|
|
198 ;; window-system stuff doesn't work before then.
|
|
|
199
|
|
|
200 (or (not running-xemacs)
|
|
|
201 (emacs-version>= 19 13)
|
|
|
202 (error "This init file does not support XEmacs before 19.13"))
|
|
|
203
|
|
|
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):
|
|
|
208
|
|
|
209 ; (cond ((and running-xemacs
|
|
|
210 ; (emacs-version>= 21 2))
|
|
|
211 ; ;;
|
|
|
212 ; ;; Code requiring XEmacs version 21.2 or newer goes here
|
|
|
213 ; ;;
|
|
|
214 ; ))
|
|
|
215
|
|
|
216 ; (cond ((emacs-version >= 19 0)
|
|
|
217 ; ;;
|
|
|
218 ; ;; Code for any vintage-19 Emacs goes here
|
|
|
219 ; ;;
|
|
|
220 ; ))
|
|
|
221
|
|
|
222 ; (cond ((and (not running-xemacs)
|
|
|
223 ; (emacs-version>= 20 0))
|
|
|
224 ; ;;
|
|
|
225 ; ;; Code specific to GNU Emacs 20 or newer (not XEmacs) goes here
|
|
|
226 ; ;;
|
|
|
227 ; ))
|
|
|
228
|
|
|
229
|
|
|
230 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
231 ;; Key Definitions ;;
|
|
|
232 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
233
|
|
|
234 ;;; Set up the function keys to do common tasks to reduce Emacs pinky
|
|
|
235 ;;; and such.
|
|
|
236
|
|
|
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
|
|
|
241 ;; work to say
|
|
|
242
|
|
|
243 ;; (global-set-key 'f5 "\C-x\C-f")
|
|
|
244
|
|
|
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 ..)
|
|
|
249
|
|
|
250 ;; Note also that you may sometimes see the idiom
|
|
|
251
|
|
|
252 ;; (define-key global-map ...)
|
|
|
253
|
|
|
254 ;; in place of (global-set-key ...). These are exactly the same.
|
|
|
255
|
|
|
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.
|
|
|
264
|
|
|
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
|
|
|
271
|
|
|
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'.
|
|
|
274
|
|
|
275 (defun Init-kill-entire-line (&optional arg)
|
|
464
|
276 "Kill the entire line.
|
|
|
277 With prefix argument, kill that many lines from point. Negative
|
|
|
278 arguments kill lines backward.
|
|
|
279
|
|
|
280 When calling from a program, nil means \"no arg\",
|
|
|
281 a number counts as a prefix arg."
|
|
462
|
282 (interactive "*P")
|
|
|
283 (let ((kill-whole-line t))
|
|
|
284 (beginning-of-line)
|
|
|
285 (call-interactively 'kill-line)))
|
|
|
286
|
|
|
287 (global-set-key 'f8
|
|
|
288 (if (fboundp 'kill-entire-line) 'kill-entire-line 'Init-kill-entire-line))
|
|
|
289
|
|
|
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.
|
|
|
299 ;;
|
|
|
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.
|
|
|
302
|
|
|
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"))
|
|
|
311
|
|
|
312 ;; Here we define our own function and then bind a key to it.
|
|
|
313
|
|
|
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:
|
|
|
319 (interactive)
|
|
|
320 (if defining-kbd-macro
|
|
|
321 (end-kbd-macro)
|
|
|
322 (start-kbd-macro nil)))
|
|
|
323
|
|
|
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
|
|
|
328 ;; sense.
|
|
|
329
|
|
|
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
|
|
|
332
|
|
|
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
|
|
|
340 ;;
|
|
|
341 ;; [(control x) (control f)]
|
|
|
342 ;;
|
|
|
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.
|
|
|
346 ;;
|
|
|
347 ;; Other examples are:
|
|
|
348 ;;
|
|
|
349 ;; [(control x) n]
|
|
|
350 ;;
|
|
|
351 ;; (You can leave out the parens when there is no modifier specified in
|
|
|
352 ;; the keystroke, and that's normally done.)
|
|
|
353 ;;
|
|
|
354 ;; [(shift control meta left)]
|
|
|
355 ;;
|
|
|
356 ;; (You can put more than one modifier in a keystroke.)
|
|
|
357 ;;
|
|
|
358 ;; (shift control meta left)
|
|
|
359 ;;
|
|
|
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
|
|
|
362 ;; done.)
|
|
|
363 ;;
|
|
|
364 ;; [(control x) (shift button3)]
|
|
|
365 ;;
|
|
|
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.)
|
|
|
375 ;;
|
|
|
376 ;; 'left
|
|
|
377 ;;
|
|
|
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"
|
|
|
380 ;; forms.)
|
|
|
381 ;;
|
|
|
382 ;; '(control C)
|
|
|
383 ;;
|
|
|
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"
|
|
|
387 ;; would.)
|
|
|
388 ;;
|
|
|
389 ;; '(control \()
|
|
|
390 ;; (Put a backslash in front of characters used in Lisp syntax.)
|
|
|
391 ;;
|
|
|
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
|
|
|
396 ;;
|
|
|
397 ;; ESC : (read-key-sequence "foo: ")
|
|
|
398 ;;
|
|
|
399 ;; .)
|
|
|
400
|
|
|
401 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
402
|
|
|
403 ;; Keystrokes to conveniently switch buffers.
|
|
|
404
|
|
|
405 ;; F6 is invaluable for flipping back and forth between two buffers
|
|
|
406 ;; you're working with.
|
|
|
407
|
|
|
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)
|
|
|
413
|
|
|
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.
|
|
|
421
|
|
|
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))))))
|
|
|
432
|
|
|
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
|
|
|
441 ;; all works.
|
|
|
442 (interactive "p")
|
|
|
443 (dotimes (n (or n 1))
|
|
|
444 (loop
|
|
|
445 do (bury-buffer (car (buffer-list)))
|
|
|
446 while (Init-buffers-tab-omit (car (buffer-list))))
|
|
|
447 (switch-to-buffer (car (buffer-list)))))
|
|
|
448
|
|
|
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)))))
|
|
|
453
|
|
|
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'.
|
|
|
462 )
|
|
|
463
|
|
|
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
|
|
|
476 buffer-to-select)))
|
|
|
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)
|
|
|
480 (eq modenm1 modenm2)
|
|
|
481 (and (string-match "^[^-]+-" mode1)
|
|
|
482 (string-match
|
|
|
483 (concat "^" (regexp-quote
|
|
|
484 (substring mode1 0 (match-end 0))))
|
|
|
485 mode2))
|
|
|
486 (and Init-buffers-tab-grouping-regexp
|
|
|
487 (find-if #'(lambda (x)
|
|
|
488 (or
|
|
|
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)))
|
|
|
494 t)
|
|
|
495 (t nil)))))
|
|
|
496
|
|
|
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."
|
|
|
503 (interactive "p")
|
|
|
504 (dotimes (n (or n 1))
|
|
|
505 (loop
|
|
|
506 do (switch-to-buffer (car (last (buffer-list))))
|
|
|
507 while (Init-buffers-tab-omit (car (buffer-list))))))
|
|
|
508
|
|
|
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."
|
|
|
515 (interactive "p")
|
|
|
516 (dotimes (n (or n 1))
|
|
|
517 (let ((curbuf (car (buffer-list))))
|
|
|
518 (loop
|
|
|
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)))))
|
|
|
524
|
|
|
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."
|
|
|
531 (interactive "p")
|
|
|
532 (dotimes (n (or n 1))
|
|
|
533 (let ((curbuf (car (buffer-list))))
|
|
|
534 (loop
|
|
|
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)))))))))
|
|
|
539
|
|
|
540 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
541
|
|
|
542 ;; Other text keystrokes.
|
|
|
543
|
|
|
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)
|
|
|
548
|
|
|
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)
|
|
|
552
|
|
|
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))
|
|
|
558
|
|
|
559 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
560
|
|
|
561 ;; Rearrange some inconvenient bindings.
|
|
|
562
|
|
|
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.
|
|
|
567 ;;
|
|
|
568 ;; Note also the use of if vs. cond/when/unless/or/and to express
|
|
|
569 ;; conditional statements. The difference is purely stylistic.
|
|
|
570
|
|
|
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))
|
|
|
574
|
|
|
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:
|
|
|
583 ;;
|
|
|
584 ;; ;(when (console-on-window-system-p)
|
|
|
585 ;; (global-set-key "\C-z" 'zap-up-to-char)
|
|
|
586 ;; ; )
|
|
|
587 ;;
|
|
|
588 ;; To do this, I first moved the closing paren to a new line,
|
|
|
589 ;; reindented with TAB, then added the semicolons.)
|
|
|
590
|
|
|
591 (when (console-on-window-system-p)
|
|
|
592 (global-set-key "\C-z" 'zap-up-to-char))
|
|
|
593
|
|
|
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
|
|
|
597 ;; File menu.
|
|
|
598
|
|
|
599 (when (console-on-window-system-p)
|
|
|
600 (global-set-key "\C-x\C-c" nil))
|
|
|
601
|
|
|
602 ;; Make C-k always delete the whole line, which is what most people want,
|
|
|
603 ;; anyway.
|
|
|
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 ()
|
|
|
607 (interactive)
|
|
|
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)
|
|
|
615
|
|
|
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 --
|
|
|
621 (condition-case nil
|
|
|
622 (progn
|
|
|
623 (require 'pc-select)
|
|
|
624 (pc-select-mode 1))
|
|
|
625 (error nil)))
|
|
|
626
|
|
|
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).
|
|
|
633 ;;
|
|
|
634 ;; The idea for this comes from Jamie Zawinski.
|
|
|
635 ;;
|
|
|
636 ;; Also make a convenient keystroke for _, used constantly in C code.
|
|
|
637 ;;
|
|
|
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.
|
|
|
641
|
|
|
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 "_")
|
|
|
651
|
|
|
652
|
|
|
653 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
654
|
|
|
655 ;; Useful programming-related keystrokes.
|
|
|
656
|
|
|
657 (defun describe-foo-at-point ()
|
|
464
|
658 "Show the documentation of the Elisp function and variable near point.
|
|
|
659 This checks in turn:
|
|
|
660
|
|
|
661 -- for a function name where point is
|
|
|
662 -- for a variable name where point is
|
|
|
663 -- for a surrounding function call
|
|
|
664 "
|
|
462
|
665 (interactive)
|
|
|
666 (let (sym)
|
|
|
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
|
|
|
670 (save-excursion
|
|
|
671 (or (not (zerop (skip-syntax-backward "_w")))
|
|
|
672 (eq (char-syntax (char-after (point))) ?w)
|
|
|
673 (eq (char-syntax (char-after (point))) ?_)
|
|
|
674 (forward-sexp -1))
|
|
|
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)))))
|
|
|
683
|
|
|
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
|
|
|
694 ;; time it's run.
|
|
|
695 (global-set-key '(meta f11) 'edebug-defun)
|
|
|
696 (global-set-key '(meta f12) 'add-change-log-entry)
|
|
|
697
|
|
|
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)
|
|
|
701
|
|
|
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."
|
|
|
707 (interactive)
|
|
|
708 (if (profiling-active-p)
|
|
|
709 (progn
|
|
|
710 (stop-profiling)
|
|
|
711 (message "...Finished profiling")
|
|
|
712 (profile-results))
|
|
|
713 (message "Profiling...")
|
|
|
714 (clear-profiling-info)
|
|
|
715 (start-profiling)))
|
|
|
716
|
|
|
717 ;; Note that sequences of C-c plus a letter are specifically
|
|
|
718 ;; reserved for users and should never be bound by any packages.
|
|
|
719
|
|
|
720 (global-set-key "\C-cp" 'toggle-profiling)
|
|
|
721
|
|
|
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)
|
|
|
726
|
|
|
727 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
728
|
|
|
729 ;; Numeric keypad.
|
|
|
730
|
|
|
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
|
|
|
736 ;;
|
|
|
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.
|
|
|
740
|
|
|
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
|
|
|
748 ;; window.
|
|
|
749
|
|
|
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)
|
|
|
761
|
|
|
762 (defun kill-current-buffer ()
|
|
464
|
763 "Kill the current buffer (prompting if it is modified)."
|
|
462
|
764 (interactive)
|
|
|
765 (kill-buffer (current-buffer)))
|
|
|
766
|
|
|
767 (defun kill-current-buffer-and-window ()
|
|
464
|
768 "Kill the current buffer (prompting if it is modified) and its window."
|
|
462
|
769 (interactive)
|
|
|
770 (kill-buffer (current-buffer))
|
|
|
771 (delete-window))
|
|
|
772
|
|
464
|
773 (defvar grep-all-files-history nil)
|
|
|
774
|
|
|
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.")
|
|
|
780
|
|
|
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.")
|
|
|
784
|
|
|
785 (defun construct-grep-all-files-command (find-segment grep-segment)
|
|
|
786 (let ((omit-annoying
|
|
|
787 (mapconcat #'(lambda (wildcard)
|
|
|
788 (concat "-name '" wildcard "' -or "))
|
|
|
789 grep-all-files-omitted-expressions
|
|
|
790 "")))
|
|
|
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))
|
|
|
794 (grep-find-use-xargs
|
|
|
795 (format "find . %s %s -type f -print | xargs %s"
|
|
|
796 find-segment omit-annoying grep-segment))
|
|
|
797 (t
|
|
|
798 (format "find . %s %s -type f -exec %s {} /dev/null \\;"
|
|
|
799 find-segment omit-annoying grep-segment)))))
|
|
462
|
800
|
|
464
|
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'.
|
|
|
805
|
|
|
806 This function does not recurse into subdirectories. If you want this,
|
|
|
807 use \\[grep-all-files-in-current-directory-and-below]."
|
|
|
808 (interactive
|
|
|
809 (progn
|
|
|
810 (require 'compile)
|
|
|
811 (list (read-shell-command "Run grep (like this): "
|
|
|
812 grep-command 'grep-all-files-history))))
|
|
462
|
813 (require 'compile)
|
|
464
|
814 (grep (construct-grep-all-files-command
|
|
|
815 "-name . -or -type d -prune -or" command)))
|
|
|
816
|
|
479
|
817 (defun grep-all-files-in-current-directory-and-below (command)
|
|
464
|
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'.
|
|
462
|
821
|
|
464
|
822 This function recurses into subdirectories. If you do not want this,
|
|
|
823 use \\[grep-all-files-in-current-directory]."
|
|
|
824 (interactive
|
|
|
825 (progn
|
|
|
826 (require 'compile)
|
|
|
827 (list (read-shell-command "Run grep (like this): "
|
|
|
828 grep-command 'grep-all-files-history))))
|
|
|
829 (require 'compile)
|
|
|
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
|
|
|
835 "")
|
|
|
836 command)))
|
|
462
|
837
|
|
|
838 (defun clear-select ()
|
|
464
|
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]."
|
|
462
|
843 (interactive "_") ;this means "preserve the active region after this command"
|
|
|
844 (backward-up-list 1)
|
|
|
845 (let ((end (save-excursion (forward-sexp) (point))))
|
|
|
846 (push-mark end nil t)))
|
|
|
847
|
|
|
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)
|
|
464
|
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)
|
|
462
|
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
|
|
|
860 ;; buffer, etc.).
|
|
|
861 (global-set-key 'kp-enter (lambda () (interactive) (set-mark-command t)))
|
|
|
862 (global-set-key '(shift kp-enter) 'repeat-complex-command)
|
|
464
|
863 (global-set-key 'pause 'repeat-complex-command) ;; useful on Windows-style kbds
|
|
462
|
864 (global-set-key '(control kp-enter) 'eval-expression)
|
|
|
865
|
|
|
866 ;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
867
|
|
|
868 ;; Misc.
|
|
|
869
|
|
|
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:
|
|
|
873
|
|
|
874 ;(setq mouse-yank-at-point t)
|
|
|
875
|
|
|
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:
|
|
|
879
|
|
|
880 ;(define-key global-map 'button3 'mouse-track-adjust)
|
|
|
881
|
|
|
882 ;(add-hook 'mouse-track-click-hook
|
|
|
883 ; (lambda (event count)
|
|
|
884 ; (if (or (/= (event-button event) 3)
|
|
|
885 ; (/= count 2))
|
|
|
886 ; nil ;; do the normal operation
|
|
|
887 ; (kill-region (point) (mark))
|
|
|
888 ; t ;; don't do the normal operations.
|
|
|
889 ; )))
|
|
|
890
|
|
|
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
|
|
|
898 ;; here by default.
|
|
|
899
|
|
|
900 ;(setq modifier-keys-are-sticky t)
|
|
|
901
|
|
|
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
|
|
|
904 ;; default.
|
|
|
905 (put 'narrow-to-region 'disabled nil)
|
|
|
906
|
|
|
907 ;; Enable obvious hyperlink following with button1.
|
|
|
908 (setq Info-button1-follows-hyperlink t)
|
|
|
909
|
|
|
910
|
|
|
911 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
912 ;; Change Some Basic Behaviors ;;
|
|
|
913 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
914
|
|
|
915 ;; Change the values of some variables.
|
|
|
916 ;; (t means true; nil means false.)
|
|
|
917 ;;
|
|
|
918 ;; Use C-h v or `Help->Commands, Variables, Keys->Describe Variable...'
|
|
|
919 ;; to find out what these variables mean.
|
|
|
920 (setq
|
|
|
921 find-file-compare-truenames t
|
|
|
922 minibuffer-max-depth nil
|
|
|
923 )
|
|
|
924
|
|
|
925 ;; When running ispell, consider all 1-3 character words as correct.
|
|
|
926 (setq ispell-extra-args '("-W" "3"))
|
|
|
927
|
|
|
928 ;;; pending-delete-mode causes typed text to replace a selection,
|
|
|
929 ;;; rather than append -- standard behavior under all window systems
|
|
|
930 ;;; nowadays.
|
|
|
931
|
|
|
932 (pending-delete-mode 1)
|
|
|
933
|
|
|
934 ;;; enable region selection with shift+arrows (on by default in 21.5
|
|
|
935 ;;; and up)
|
|
|
936 (setq shifted-motion-keys-select-region t)
|
|
|
937
|
|
|
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")
|
|
|
948
|
|
464
|
949 ;; Make Meta+accelerator traverse to the menu in new enough XEmacs
|
|
462
|
950 ;; versions. Note that this only overrides Meta bindings that would
|
|
464
|
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'.)
|
|
|
958 ;;
|
|
|
959 ;; More specifically, the following bindings are overridden:
|
|
|
960 ;;
|
|
|
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)
|
|
|
971
|
|
462
|
972 (setq menu-accelerator-enabled 'menu-force)
|
|
|
973
|
|
|
974 ;; Make Cygwin `make' work inside a shell buffer.
|
|
|
975 (setenv "MAKE_MODE" "UNIX"))
|
|
|
976
|
|
|
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
|
|
|
982 ; '(
|
|
|
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/")
|
|
|
989 ; ;; etc.
|
|
|
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/")
|
|
|
996 ; ))
|
|
|
997
|
|
|
998
|
|
|
999 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1000 ;; Change Some Aspects of GUI Appearance ;;
|
|
|
1001 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1002
|
|
|
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
|
|
|
1008 ;; XEmacs with.)
|
|
|
1009
|
|
|
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\\)?$"
|
|
|
1015 emacs-version)
|
|
|
1016 (match-string 1 emacs-version))
|
|
|
1017 " [" invocation-directory invocation-name "]")))
|
|
|
1018
|
|
|
1019 ;; Load some nifty sounds that will replace the default beep.
|
|
|
1020 ;;
|
|
|
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.)
|
|
|
1025
|
|
|
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))
|
|
|
1036 (t
|
|
|
1037 (setq bell-volume 40)
|
|
|
1038 (setq sound-alist
|
|
|
1039 (append sound-alist '((no-completion :pitch 500))))
|
|
|
1040 ))
|
|
|
1041
|
|
|
1042 ;; Change the continuation glyph face so it stands out more
|
|
|
1043 (make-face-bold (glyph-face continuation-glyph))
|
|
|
1044
|
|
|
1045 ;; Change the pointer used during garbage collection.
|
|
|
1046 ;;
|
|
|
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)))
|
|
|
1054
|
|
|
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.
|
|
|
1061 (if (featurep 'xpm)
|
|
|
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
|
|
|
1066 '(pointer))
|
|
|
1067 (error nil)) ; returns nil if an error occurred.
|
|
|
1068 (set-glyph-image gc-pointer-glyph file))))
|
|
|
1069
|
|
|
1070 ;(when (featurep 'menubar)
|
|
|
1071 ; ;; Add `dired' to the File menu
|
|
|
1072 ; (add-menu-button '("File") ["Edit Directory" dired])
|
|
|
1073
|
|
|
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]))
|
|
|
1080
|
|
|
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:
|
|
|
1084
|
|
|
1085 ;; local emacs background: whitesmoke [i.e. the default color]
|
|
|
1086 ;; remote emacs background: palegreen1
|
|
|
1087 ;; root emacs background: coral2
|
|
|
1088
|
|
|
1089 ;; Uncomment to enable.
|
|
|
1090
|
|
|
1091 ;(cond
|
|
|
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") ""))
|
|
|
1098 ; (remote-p (not
|
|
|
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")
|
|
|
1106 ; (t nil))))
|
|
|
1107 ; (cond (bg
|
|
|
1108 ; (let ((def (color-name (face-background 'default)))
|
|
|
1109 ; (faces (face-list)))
|
|
|
1110 ; (while faces
|
|
|
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)))))))))
|
|
|
1115
|
|
|
1116
|
|
|
1117 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1118 ;; Changing the Modeline ;;
|
|
|
1119 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1120
|
|
|
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)
|
|
|
1125
|
|
|
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.
|
|
|
1129
|
|
|
1130 (setq-default
|
|
|
1131 modeline-format
|
|
|
1132 (list
|
|
|
1133 ""
|
|
|
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
|
|
|
1138 (cons 15 (list
|
|
|
1139 (list 'line-number-mode "L%l ")
|
|
|
1140 (list 'column-number-mode "C%c ")
|
|
|
1141 (cons -3 "%p"))))
|
|
|
1142 (cons modeline-buffer-id-right-extent "%17b")))
|
|
|
1143 " "
|
|
|
1144 'global-mode-string
|
|
|
1145 " %[("
|
|
|
1146 (cons modeline-minor-mode-extent
|
|
|
1147 (list "" 'mode-name 'minor-mode-alist))
|
|
|
1148 (cons modeline-narrowed-extent "%n")
|
|
|
1149 'modeline-process
|
|
|
1150 ")%]----"
|
|
|
1151 "%-"
|
|
|
1152 ))
|
|
|
1153
|
|
|
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))) ""))
|
|
|
1162
|
|
|
1163
|
|
|
1164
|
|
|
1165 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1166 ;; Customization of Specific Packages ;;
|
|
|
1167 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
1168
|
|
|
1169
|
|
|
1170 ;;; ********************
|
|
|
1171 ;;; Load gnuserv, which will allow you to connect to XEmacs sessions
|
|
|
1172 ;;; using `gnuclient'.
|
|
|
1173
|
|
|
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.
|
|
|
1177 ; (gnuserv-start)
|
|
|
1178
|
|
|
1179
|
|
|
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.
|
|
|
1184 ;;;
|
|
|
1185 (require 'dired)
|
|
|
1186 ;; compatible ange-ftp/efs initialization derived from code
|
|
|
1187 ;; from John Turner <turner@lanl.gov>
|
|
|
1188 ;;
|
|
|
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.
|
|
|
1193
|
|
|
1194 (condition-case nil
|
|
|
1195 (progn
|
|
|
1196 (require 'efs-auto)
|
|
|
1197 (if (getenv "USER")
|
|
|
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))
|
|
|
1206 (error
|
|
|
1207 (require 'ange-ftp)
|
|
|
1208 (if (getenv "USER")
|
|
|
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)
|
|
|
1217 ))
|
|
|
1218
|
|
|
1219
|
|
|
1220 ;;; ********************
|
|
|
1221 ;;; Load the default-dir.el package which installs fancy handling of
|
|
|
1222 ;;; the initial contents in the minibuffer when reading file names.
|
|
|
1223
|
|
|
1224 ;(condition-case nil
|
|
|
1225 ; (require 'default-dir)
|
|
|
1226 ; (error nil))
|
|
|
1227
|
|
|
1228
|
|
|
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!)
|
|
|
1236 ;;;
|
|
|
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
|
|
|
1244 efs-auto-save t
|
|
|
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
|
|
|
1249 )
|
|
|
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)
|
|
|
1253 )
|
|
|
1254
|
|
|
1255
|
|
|
1256 ;;; ********************
|
|
|
1257 ;;; cc-mode (the mode you're in when editing C, C++, and Objective C files)
|
|
|
1258
|
|
|
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)
|
|
|
1262
|
|
|
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)))
|
|
|
1267
|
|
|
1268
|
|
|
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.
|
|
|
1275 ;;;
|
|
|
1276 (load-library "completer")
|
|
|
1277
|
|
|
1278
|
|
|
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.
|
|
|
1283 ;;;
|
|
|
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.
|
|
|
1289 )
|
|
|
1290 (require 'crypt)
|
|
|
1291
|
|
|
1292
|
|
|
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.
|
|
|
1297
|
|
|
1298 (require 'filladapt)
|
|
|
1299 (setq-default filladapt-mode t)
|
|
|
1300 (add-hook 'c-mode-hook 'turn-off-filladapt-mode)
|
|
|
1301
|
|
|
1302
|
|
|
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
|
|
|
1310 ;;; programs.
|
|
|
1311 ;;;
|
|
|
1312 ;;; The "Options" menu has some commands for controlling this as well.
|
|
|
1313 ;;;
|
|
|
1314 (cond (running-xemacs
|
|
|
1315
|
|
|
1316 ;; The commented-out code below is an example of setting up custom
|
|
|
1317 ;; font-lock colors.
|
|
|
1318
|
|
|
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)
|
|
|
1326
|
|
|
1327 (require 'font-lock)
|
|
|
1328
|
|
|
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.
|
|
|
1333
|
|
|
1334 ; ;; string face is green
|
|
|
1335 ; (set-face-foreground 'font-lock-string-face "forest green")
|
|
|
1336
|
|
|
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")
|
|
|
1344
|
|
|
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")
|
|
|
1348
|
|
|
1349 ; ;; misc. faces
|
|
|
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])
|
|
|
1353 ))
|
|
|
1354
|
|
|
1355
|
|
|
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.
|
|
|
1362
|
|
|
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)
|
|
|
1368
|
|
|
1369
|
|
|
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.
|
|
|
1376 ;;;
|
|
|
1377 ;;; Send bug reports, enhancements etc to:
|
|
|
1378 ;;; David Hughes <ukchugd@ukpmr.cs.philips.nl>
|
|
|
1379 ;;;
|
|
|
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)
|
|
|
1386
|
|
|
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)
|
|
|
1392
|
|
|
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)
|
|
|
1404 ))
|
|
|
1405
|
|
|
1406
|
|
|
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".
|
|
|
1411 ;;;
|
|
|
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)
|
|
|
1416
|
|
|
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)
|
|
|
1421
|
|
|
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/")
|
|
|
1426
|
|
|
1427
|
|
|
1428 ;;; ********************
|
|
|
1429 ;;; resize-minibuffer-mode makes the minibuffer automatically
|
|
|
1430 ;;; resize as necessary when it's too big to hold its contents.
|
|
|
1431
|
|
|
1432 (autoload 'resize-minibuffer-mode "rsz-minibuf" nil t)
|
|
|
1433 (resize-minibuffer-mode)
|
|
|
1434 (setq resize-minibuffer-window-exactly nil)
|
|
|
1435
|
|
|
1436
|
|
|
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.
|
|
|
1439
|
|
|
1440 (require 'scroll-in-place)
|
|
|
1441 (turn-on-scroll-in-place)
|
|
|
1442
|
|
|
1443
|
|
|
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:
|
|
|
1449
|
|
|
1450 ;(setq w3-use-telnet t
|
|
|
1451 ; ;;
|
|
|
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"
|
|
|
1455 ; ;;
|
|
|
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
|
|
|
1459 ; )
|
