|
0
|
1 ;;; -*- Mode:Emacs-Lisp -*-
|
|
|
2 ;;; Copyright © 1992-1993 by Lucid, Inc. All Rights Reserved.
|
|
|
3 ;;; Energize support for the Editor of the Beast, and others.
|
|
|
4
|
|
|
5 (evi-define-key '(vi motion ex) "\C-x" 'evi-emacs-command)
|
|
|
6 (evi-define-key '(vi motion) "\177" 'evi-backward-char)
|
|
|
7 (evi-define-key '(vi) "\C-z" 'evi-quit-evi)
|
|
|
8
|
|
|
9 (evi-define-key '(vi motion top-level) 'button3 'energize-popup-menu)
|
|
|
10
|
|
|
11 (setq evi-meta-prefix-char ?\C-a)
|
|
|
12
|
|
|
13 (defvar energize-external-editor nil) ; nil, vi, or a string
|
|
|
14 (defvar energize-internal-editor nil) ; nil or vi
|
|
|
15 (defvar energize-internal-viewer nil) ; nil, vi, or less
|
|
|
16 (defvar energize-vi-terminal-emulator nil) ; xterm, shelltool, or cmdtool
|
|
|
17
|
|
|
18 (defun ex-quit (discard)
|
|
|
19 ;; originally defined in evi.el
|
|
|
20 ;; The old version would exit emacs; this version just kills the current
|
|
|
21 ;; buffer and deletes the current window (and frame if appropriate.)
|
|
|
22 (and (not discard) (buffer-file-name) (buffer-modified-p)
|
|
|
23 (evi-error
|
|
|
24 "No write since last change (use :quit! to override)"))
|
|
|
25 ;; #### Since we're unmodifying this buffer with the intent of killing it,
|
|
|
26 ;; we need to avoid telling Energize that we have unmodified it, or for some
|
|
|
27 ;; reason it recreates the buffer later. I don't understand...
|
|
|
28 (let ((energize-buffer-modified-hook nil))
|
|
|
29 (set-buffer-modified-p nil))
|
|
|
30 (delete-auto-save-file-if-necessary)
|
|
|
31 (kill-buffer (current-buffer))
|
|
|
32 (setq ex-user-buffer (current-buffer))
|
|
|
33 (condition-case nil
|
|
|
34 (delete-window (selected-window))
|
|
|
35 ;; ignore error about trying to delete only window on only frame
|
|
|
36 (error nil))
|
|
|
37 )
|
|
|
38
|
|
|
39 (defun ex-write-all-and-quit (quietly)
|
|
|
40 ;; originally defined in evi.el
|
|
|
41 ;; The old version would exit emacs; this version just kills the current
|
|
|
42 ;; buffer and deletes the current window (and frame if appropriate.)
|
|
|
43 (save-some-buffers quietly)
|
|
|
44 (ex-quit t))
|
|
|
45
|
|
|
46 (defun energize-external-editor-set-menubar ()
|
|
|
47 "Set the menubar to be used for the external editor"
|
|
|
48 (delete-menu-item '("File" "Open..."))
|
|
|
49 (add-menu-item '("File") "View..." 'find-file-other-window t
|
|
|
50 "Save")
|
|
|
51 (add-menu-item '("File") '("Edit" . "")
|
|
|
52 'energize-edit-buffer-externally t "Save")
|
|
|
53 (delete-menu-item '("File" "Exit XEmacs")))
|
|
|
54
|
|
|
55 (defun energize-internal-editor-set-menubar ()
|
|
|
56 "Set the menubar to be used for the internal editor"
|
|
|
57 (add-menu-item '("File") "Open..." 'find-file t "Save")
|
|
|
58 (delete-menu-item '("File" "View..."))
|
|
|
59 (delete-menu-item '("File" "Edit"))
|
|
|
60 (add-menu-item '("File") "Exit XEmacs" 'save-buffers-kill-emacs t))
|
|
|
61
|
|
|
62
|
|
|
63 (defun sensitize-external-editor-menus-hook ()
|
|
|
64 ;; make the "Edit File" menu item be inactive if this buffer doesn't have a
|
|
|
65 ;; file, and make it contain the name of the file that will be edited.
|
|
|
66 (let* ((menu (cdr (car (find-menu-item current-menubar '("File")))))
|
|
|
67 (ef (car (find-menu-item menu '("Edit File")))))
|
|
|
68 (if (null ef)
|
|
|
69 t ; no change
|
|
|
70 (let ((name buffer-file-name))
|
|
|
71 (if (eq (energize-buffer-type (current-buffer))
|
|
|
72 'energize-top-level-buffer)
|
|
|
73 (setq name nil))
|
|
|
74 (aset ef 2 (if name t nil))
|
|
|
75 (aset ef 3 (if name (file-name-nondirectory buffer-file-name) nil))
|
|
|
76 nil))))
|
|
|
77
|
|
|
78 (add-hook 'activate-menubar-hook 'sensitize-external-editor-menus-hook)
|
|
|
79
|
|
|
80 (defun energize-edit-buffer-externally-p (buffer)
|
|
|
81 (and energize-external-editor
|
|
|
82 (eq 'energize-source-buffer (energize-buffer-type buffer))))
|
|
|
83
|
|
|
84 (defun energize-edit-buffer-externally-1 (buffer extent)
|
|
|
85 (save-excursion
|
|
|
86 (set-buffer buffer)
|
|
|
87 (cond ((numberp extent)
|
|
|
88 (goto-char extent))
|
|
|
89 ((null extent)
|
|
|
90 (goto-char 1))
|
|
|
91 (t
|
|
|
92 (goto-char (extent-start-position extent))))
|
|
|
93 (energize-begin-external-edit (buffer-file-name)
|
|
|
94 (save-excursion
|
|
|
95 (beginning-of-line)
|
|
|
96 (1+ (count-lines 1 (point)))))))
|
|
|
97
|
|
|
98 (defun energize-edit-buffer-externally ()
|
|
|
99 "Edit the currently-displayed buffer in $ENERGIZE_EDIT_MODE."
|
|
|
100 (interactive)
|
|
|
101 (if (not buffer-file-name)
|
|
|
102 (error "Buffer not associated with a file"))
|
|
|
103 (energize-edit-buffer-externally-1 (current-buffer) (point)))
|
|
|
104
|
|
|
105
|
|
|
106 ;;; keeping track of inferior vi processes
|
|
|
107 ;;; the energize_vi command can locate and reuse a running vi, but that's
|
|
|
108 ;;; an expensive operation on X terminals, since the query-tree takes a
|
|
|
109 ;;; *lot* of server traffic. So if we know that there's no vi editing the
|
|
|
110 ;;; file (at least not one that *we* started) we can tell it to go ahead
|
|
|
111 ;;; and start a new one without checking for an old one. If we used a
|
|
|
112 ;;; smarter wrapper (one that told us the window id, or talked to the kernel
|
|
|
113 ;;; directly) instead of xterm, we wouldn't need the query-tree at all.
|
|
|
114
|
|
|
115 (defvar energize-vi-procs nil) ; vi is a special case (we're more clever)
|
|
|
116 (defvar energize-other-external-editor-procs nil) ; random others
|
|
|
117
|
|
|
118 (defun energize-vi-buffer-being-edited-p (file)
|
|
|
119 (let ((rest energize-vi-procs)
|
|
|
120 result)
|
|
|
121 (while rest
|
|
|
122 (if (string-equal file (cdr (car rest)))
|
|
|
123 (setq result t
|
|
|
124 rest nil)
|
|
|
125 (setq rest (cdr rest))))
|
|
|
126 result))
|
|
|
127
|
|
|
128 (defvar energize-vi-wrapper "energize_vi")
|
|
|
129
|
|
|
130 (defun energize-begin-external-edit (file line)
|
|
|
131 (let* ((ez-path (getenv "ENERGIZE_PATH"))
|
|
|
132 (exec-path (if ez-path
|
|
|
133 (append exec-path (list ez-path))
|
|
|
134 exec-path))
|
|
|
135 (dir (file-name-directory file))
|
|
|
136 (name (file-name-nondirectory file))
|
|
|
137 (vi-p (eq energize-external-editor 'vi))
|
|
|
138 (program (if vi-p energize-vi-wrapper energize-external-editor))
|
|
|
139 (pretty (cond (vi-p "vi")
|
|
|
140 ((string-match "[ \t]" program) program)
|
|
|
141 (t (file-name-nondirectory program))))
|
|
|
142 (procname (format "*%s %s*" (if vi-p "energize_vi" pretty) name))
|
|
|
143 (edited-p (and vi-p (energize-vi-buffer-being-edited-p file)))
|
|
|
144 proc msg)
|
|
|
145 (setq line (if vi-p (format "+%d" line) "")
|
|
|
146 msg (format "%s %s %s %s..." (if edited-p "Reselecting" "Launching")
|
|
|
147 pretty name line))
|
|
|
148 (message "%s" msg)
|
|
|
149 (let ((default-directory dir)
|
|
|
150 (inhibit-quit t))
|
|
|
151 (cond (vi-p
|
|
|
152 (setq proc
|
|
|
153 (apply 'start-process procname nil program
|
|
|
154 dir name line
|
|
|
155 (cond ((eq energize-vi-terminal-emulator 'xterm)
|
|
|
156 "-xterm")
|
|
|
157 ((eq energize-vi-terminal-emulator 'cmdtool)
|
|
|
158 "-cmdtool")
|
|
|
159 ((eq energize-vi-terminal-emulator 'shelltool)
|
|
|
160 "-shelltool")
|
|
|
161 (t
|
|
|
162 (signal 'error
|
|
|
163 (list
|
|
|
164 "energize-vi-terminal-emulator unknown"
|
|
|
165 energize-vi-terminal-emulator))))
|
|
|
166 (if edited-p '("-search") '())))
|
|
|
167 (setq energize-vi-procs (cons (cons proc file) energize-vi-procs))
|
|
|
168 (set-process-sentinel proc 'energize-vi-sentinel)
|
|
|
169 (set-process-filter proc 'energize-vi-filter))
|
|
|
170 (t
|
|
|
171 ;; ### hack a %-spec for line number info
|
|
|
172 ;; (setq proc (start-process procname nil program name))
|
|
|
173 (setq proc (start-process procname nil "/bin/sh" "-c"
|
|
|
174 (concat program " " name)))
|
|
|
175 (setq energize-other-external-editor-procs
|
|
|
176 (cons (cons proc file)
|
|
|
177 energize-other-external-editor-procs))
|
|
|
178 (set-process-sentinel proc 'energize-external-editor-sentinel)
|
|
|
179 (set-process-filter proc 'energize-external-editor-filter))))
|
|
|
180 (if edited-p
|
|
|
181 (while (progn (accept-process-output)
|
|
|
182 (eq 'run (process-status proc)))
|
|
|
183 (sleep-for 1))
|
|
|
184 (accept-process-output)
|
|
|
185 (sit-for 1))
|
|
|
186 (if (eq 0 (process-exit-status proc)) ; don't blow away error message
|
|
|
187 (message "%s Done." msg))
|
|
|
188 nil))
|
|
|
189
|
|
|
190 (defun energize-external-editor-sentinel-1 (process state name list-var)
|
|
|
191 (let ((rest (symbol-value list-var))
|
|
|
192 (got-it nil))
|
|
|
193 (let ((inhibit-quit t))
|
|
|
194 (while rest
|
|
|
195 (if (eq process (car (car rest)))
|
|
|
196 (progn
|
|
|
197 (set list-var (delq (car rest) (symbol-value list-var)))
|
|
|
198 (setq got-it (car rest)
|
|
|
199 rest nil)))
|
|
|
200 (setq rest (cdr rest))))
|
|
|
201 (if got-it
|
|
|
202 (progn
|
|
|
203 (energize-notice-external-editor-termination (cdr got-it))
|
|
|
204
|
|
|
205 (if (and state (string-match "\n+\\'" state))
|
|
|
206 (setq state (substring state 0 (match-beginning 0))))
|
|
|
207 (if (and (not (eq 0 (process-exit-status (car got-it))))
|
|
|
208 state
|
|
|
209 (not (equal state "")))
|
|
|
210 (error "%s: %s" (process-name process) state))
|
|
|
211
|
|
|
212 ; (if (not (eq 0 (process-exit-status (car got-it))))
|
|
|
213 ; (error "vi process exited with code %s"
|
|
|
214 ; (process-exit-status (car got-it))))
|
|
|
215
|
|
|
216 )
|
|
|
217 (beep)
|
|
|
218 (message "unknown %s process died with %S" name state))))
|
|
|
219
|
|
|
220 (defun energize-vi-sentinel (process state)
|
|
|
221 (energize-external-editor-sentinel-1 process state "vi" 'energize-vi-procs))
|
|
|
222
|
|
|
223 (defun energize-external-editor-sentinel (process state)
|
|
|
224 (energize-external-editor-sentinel-1
|
|
|
225 process state "external editor" 'energize-other-external-editor-procs))
|
|
|
226
|
|
|
227 (defun energize-external-editor-filter (process output)
|
|
|
228 (beep)
|
|
70
|
229 (message "%s" output))
|
|
0
|
230
|
|
|
231 (defun energize-vi-filter (process output)
|
|
|
232 ;; this will only get called if energize_vi (or the xterm) print error msgs
|
|
|
233 (energize-external-editor-filter process output))
|
|
|
234
|
|
|
235 (defun energize-notice-external-editor-termination (filename)
|
|
|
236 ;;
|
|
|
237 ;; when an external vi process edits, automatically revert any buffers
|
|
|
238 ;; associated with the file that was being edited, unless those buffers
|
|
|
239 ;; are modified (which shouldn't really happen in the vi model or doing
|
|
|
240 ;; things.)
|
|
|
241 ;;
|
|
|
242 ;; ## Since one vi process may have edited several files, possibly we
|
|
|
243 ;; ## should map over all energize files and revert as appropriate instead
|
|
|
244 ;; ## of only checking the file that the vi in question was started to edit.
|
|
|
245 ;;
|
|
|
246 (let ((buffer (get-file-buffer filename)))
|
|
|
247 (cond ((null buffer)
|
|
|
248 nil)
|
|
|
249 ((verify-visited-file-modtime buffer)
|
|
|
250 nil)
|
|
|
251 ((buffer-modified-p buffer) ; Hey, how'd that happen?
|
|
|
252 (if (not (file-exists-p filename))
|
|
|
253 (error "File %s no longer exists! Buffer modified!"
|
|
|
254 (file-name-nondirectory filename))
|
|
|
255 (beep)
|
|
|
256 (if (yes-or-no-p
|
|
|
257 (format "File %s changed on disk. Discard your edits? "
|
|
|
258 (file-name-nondirectory filename)))
|
|
|
259 (save-excursion
|
|
|
260 (set-buffer buffer)
|
|
|
261 (revert-buffer t t)))))
|
|
|
262 ; ((not (file-exists-p filename)) ; File gone; kill buffer.
|
|
|
263 ; (kill-buffer buffer))
|
|
|
264 (t ; not modified; just revert
|
|
|
265 (let* ((w (get-buffer-window buffer)) ; let's not thrash so much
|
|
|
266 (p (and w (window-point w)))
|
|
|
267 (s (and w (window-start w))))
|
|
|
268 (save-excursion
|
|
|
269 (set-buffer buffer)
|
|
|
270 (revert-buffer t t))
|
|
|
271 (if p (set-window-point w p))
|
|
|
272 (if s (set-window-start w s)))))))
|
|
|
273
|
|
|
274
|
|
|
275 ;; evi mode
|
|
|
276
|
|
|
277 (defun energize-evi-mode ()
|
|
|
278 (evi)
|
|
|
279 ;; vi users like to be able to edit read-only files, but we shouldn't
|
|
|
280 ;; let them edit the Energize non-file buffers.
|
|
|
281 (if (and (energize-buffer-p (current-buffer))
|
|
|
282 (or (null buffer-file-name)
|
|
|
283 (memq (energize-buffer-type (current-buffer))
|
|
|
284 '(energize-top-level-buffer energize-browser-buffer
|
|
|
285 energize-error-log-buffer energize-includers-buffer))))
|
|
|
286 (setq buffer-read-only t))
|
|
|
287 )
|
|
|
288
|
|
|
289
|
|
|
290 (defun energize-external-editor-set-mode (buffer)
|
|
|
291 ;; If an external editor is in use, then source buffers should be
|
|
|
292 ;; read-only in one manner or another.
|
|
|
293 (save-excursion
|
|
|
294 (set-buffer buffer)
|
|
|
295 (let* ((type (energize-buffer-type buffer))
|
|
|
296 (debugger-p (eq type 'energize-debugger-buffer))
|
|
|
297 (always-editable-p (memq type '(energize-project-buffer
|
|
|
298 energize-debugger-buffer
|
|
|
299 energize-breakpoint-buffer
|
|
|
300 )))
|
|
|
301 (editable-p (or always-editable-p
|
|
|
302 (and (null energize-external-editor)
|
|
|
303 (not buffer-read-only)))))
|
|
|
304
|
|
|
305 (or editable-p (setq buffer-read-only t))
|
|
|
306 (cond (editable-p
|
|
|
307 (cond ((eq energize-internal-editor nil)
|
|
|
308 nil)
|
|
|
309 ((eq energize-internal-editor 'vi)
|
|
|
310 (if (not debugger-p)
|
|
|
311 (energize-evi-mode)))
|
|
|
312 (t
|
|
|
313 (signal 'error
|
|
|
314 (list "unknown value for energize-internal-editor"
|
|
|
315 energize-internal-editor)))))
|
|
|
316 ((eq energize-internal-viewer 'vi)
|
|
|
317 (energize-evi-mode))
|
|
|
318 ((eq energize-internal-viewer 'less)
|
|
|
319 ;; put it in view-mode, but don't change the major-mode symbol
|
|
|
320 ;; so that the buffers go in the appropriate frames.
|
|
|
321 (let ((major-mode major-mode))
|
|
|
322 (view-mode)))
|
|
|
323 ((eq energize-internal-viewer 'nil)
|
|
|
324 nil)
|
|
|
325 (t
|
|
|
326 (signal 'error
|
|
|
327 (list "unknown value for energize-internal-viewer"
|
|
|
328 energize-internal-viewer)))))))
|
|
|
329
|
|
|
330 (defun external-editor-hack-popup (choices)
|
|
|
331 (if energize-external-editor
|
|
|
332 (let ((rest choices)
|
|
|
333 file)
|
|
|
334 (while rest
|
|
|
335 (if (and (vectorp (car rest))
|
|
|
336 (equal "editfile" (aref (car rest) 0))
|
|
|
337 (>= (length (car rest)) 4)
|
|
|
338 (stringp (setq file (aref (car rest) 3))))
|
|
|
339 (progn
|
|
|
340 (setcdr rest
|
|
|
341 (cons (vector "View File"
|
|
|
342 (list 'pop-to-buffer
|
|
|
343 (list 'find-file-noselect file))
|
|
|
344 t file)
|
|
|
345 (cdr rest)))
|
|
|
346 (setq rest nil)))
|
|
|
347 (setq rest (cdr rest)))))
|
|
|
348 choices)
|
|
|
349
|
|
|
350
|
|
|
351
|
|
|
352 (defvar energize-search-match-data nil)
|
|
|
353
|
|
|
354 (defun energize-search-internal (args)
|
|
|
355 ;; called from editorside.c
|
|
|
356 (let* ((case-fold-search (not (nth 0 args)))
|
|
|
357 (match-word-p (nth 1 args))
|
|
|
358 (regexp-string-p (nth 2 args)) ; string for which to search is regex
|
|
|
359 (regexp-p (or match-word-p regexp-string-p)) ; use regex function?
|
|
|
360 (back-p (not (nth 3 args)))
|
|
|
361 (search-string (nth 4 args))
|
|
|
362 (search (if match-word-p
|
|
|
363 (concat "\\b"
|
|
|
364 (if regexp-string-p ; coerce to regexp
|
|
|
365 search-string
|
|
|
366 (regexp-quote search-string))
|
|
|
367 "\\b")
|
|
|
368 search-string))
|
|
|
369 (replace (nth 5 args))
|
|
|
370 (fn (if back-p
|
|
|
371 (if regexp-p 're-search-backward 'search-backward)
|
|
|
372 (if regexp-p 're-search-forward 'search-forward))))
|
|
|
373 (setq this-command 'energize-search)
|
|
|
374 (cond ((equal search "")
|
|
|
375 (setq energize-search-match-data nil)
|
|
|
376 (error "No search string specified")))
|
|
|
377 (cond ((consp replace)
|
|
|
378 ;; the "replace all" button was selected
|
|
|
379 (setq replace (car replace))
|
|
|
380 ;; replace the one just searched for, if any
|
|
|
381 (cond ((and (eq last-command 'energize-search)
|
|
|
382 energize-search-match-data)
|
|
|
383 (store-match-data energize-search-match-data)
|
|
|
384 (if back-p
|
|
|
385 (save-excursion
|
|
|
386 (replace-match replace nil (not regexp-p)))
|
|
|
387 (replace-match replace nil (not regexp-p)))))
|
|
|
388 ;; now replace all the rest
|
|
|
389 (let ((count 0))
|
|
|
390 (while (funcall fn search nil t)
|
|
|
391 (if back-p
|
|
|
392 (save-excursion
|
|
|
393 (replace-match replace nil (not regexp-p)))
|
|
|
394 (replace-match replace nil (not regexp-p)))
|
|
|
395 (setq count (1+ count)))
|
|
|
396 (message "%d replacement%s done." count (if (= count 1) "" "s")))
|
|
|
397 ;; (setq this-command nil)
|
|
|
398 (setq energize-search-match-data nil))
|
|
|
399 (t
|
|
|
400 ;; otherwise, one of the search buttons was selected
|
|
|
401 (cond (replace
|
|
|
402 (or (eq last-command 'energize-search) ; fuck!!
|
|
|
403 (error "Last command was not a successful search."))
|
|
|
404 (or energize-search-match-data (error "Last search failed"))
|
|
|
405 (store-match-data energize-search-match-data)
|
|
|
406 (if back-p
|
|
|
407 (save-excursion
|
|
|
408 (replace-match replace nil (not regexp-p)))
|
|
|
409 (replace-match replace nil (not regexp-p)))))
|
|
|
410 (setq energize-search-match-data nil)
|
|
|
411 (or (funcall fn search nil t)
|
|
|
412 (signal 'error
|
|
|
413 (list (cond ((and back-p regexp-p)
|
|
|
414 "Reverse regexp search failed")
|
|
|
415 (back-p "Reverse search failed")
|
|
|
416 (regexp-p "Regexp search failed")
|
|
|
417 (t "Search failed"))
|
|
|
418 search)))
|
|
|
419 (cond (zmacs-regions
|
|
|
420 (push-mark (if (= (point) (match-beginning 0))
|
|
|
421 (match-end 0)
|
|
|
422 (match-beginning 0))
|
|
|
423 t)
|
|
|
424 (zmacs-activate-region)))
|
|
|
425 (setq energize-search-match-data (match-data))
|
|
|
426 ))))
|
|
|
427
|
|
|
428
|
|
|
429 (defvar energize-edit-modes-specified nil)
|
|
|
430
|
|
|
431 (defun energize-set-edit-modes-minibuf-prompt ()
|
|
|
432 (let* ((ee (completing-read "External editor (RET for none): "
|
|
|
433 nil nil nil nil t))
|
|
|
434 (te (if (equal ee "vi")
|
|
|
435 (completing-read
|
|
|
436 "Terminal emulator in which to run vi (xterm, shelltool, or cmdtool): "
|
|
|
437 '(("xterm") ("shelltool") ("cmdtool")) nil t nil t)
|
|
|
438 ""))
|
|
|
439 (iv (completing-read
|
|
|
440 "View buffers using which keybindings (emacs, vi, or less): "
|
|
|
441 '(("emacs") ("vi") ("less")) nil t nil t))
|
|
|
442 (ie (completing-read
|
|
|
443 "Edit other buffers using which keybindings (emacs or vi): "
|
|
|
444 '(("emacs") ("vi")) nil t nil t))
|
|
|
445 (ms (y-or-n-p "Use multiple windows? "))
|
|
|
446 (sp (y-or-n-p "Split screens? "))
|
|
|
447 )
|
|
|
448 (if (equal ee "") (setq ee nil))
|
|
|
449 (if (equal te "") (setq te "xterm"))
|
|
|
450 (if (equal iv "") (setq iv "emacs"))
|
|
|
451 (if (equal ie "") (setq ie "emacs"))
|
|
|
452 (list ee (intern te) (intern iv) (intern ie) ms sp)))
|
|
|
453
|
|
|
454 (defun energize-set-edit-modes-dbox-prompt ()
|
|
|
455 (let* ((ee (cond ((member energize-external-editor '("" "emacs" nil)) 0)
|
|
|
456 ((member energize-external-editor '("vi" vi))
|
|
|
457 (cond ((eq energize-vi-terminal-emulator 'xterm) 1)
|
|
|
458 ((eq energize-vi-terminal-emulator 'cmdtool) 2)
|
|
|
459 (t (error "unrecognised terminal emulator"))))
|
|
|
460 (t 3)))
|
|
|
461 (o (if (and (stringp energize-external-editor)
|
|
|
462 (not (equal energize-external-editor "vi")))
|
|
|
463 energize-external-editor
|
|
|
464 ""))
|
|
|
465 (iv (cond ((memq energize-internal-viewer '(nil emacs)) 0)
|
|
|
466 ((eq energize-internal-viewer 'vi) 1)
|
|
|
467 ((eq energize-internal-viewer 'less) 2)
|
|
|
468 (t (error "unrecognised internal-viewer"))))
|
|
|
469 (ie (cond ((memq energize-internal-editor '(nil emacs)) 0)
|
|
|
470 ((eq energize-internal-editor 'vi) 1)
|
|
|
471 (t (error "unrecognised internal-editor"))))
|
|
|
472 (ms (cond ((memq energize-screen-mode '(nil single)) 0)
|
|
|
473 ((eq energize-screen-mode 'several) 1)
|
|
|
474 ((eq energize-screen-mode 'multi) 2)
|
|
|
475 (t (error "unrecognised screen-mode"))))
|
|
|
476 (sp (if energize-split-screens-p 1 0))
|
|
|
477
|
|
|
478 (result (energize-edit-mode-prompt ee ie iv o ms sp))
|
|
|
479 )
|
|
|
480 (setq ee (nth 0 result)
|
|
|
481 iv (nth 1 result)
|
|
|
482 ie (nth 2 result)
|
|
|
483 o (nth 3 result)
|
|
|
484 ms (nth 4 result)
|
|
|
485 sp (nth 5 result))
|
|
|
486 (list (cond ((= ee 0) nil)
|
|
|
487 ((= ee 1) "vi")
|
|
|
488 ((= ee 2) "vi")
|
|
|
489 ((= ee 3) o)
|
|
|
490 (t (error "ee losing")))
|
|
|
491 (cond ((= ee 1) 'xterm)
|
|
|
492 ((= ee 2) 'cmdtool)
|
|
|
493 (t nil))
|
|
|
494 (cond ((= iv 0) 'emacs)
|
|
|
495 ((= iv 1) 'vi)
|
|
|
496 ((= iv 2) 'less)
|
|
|
497 (t (error "iv losing")))
|
|
|
498 (cond ((= ie 0) 'emacs)
|
|
|
499 ((= ie 1) 'vi)
|
|
|
500 (t (error "ie losing")))
|
|
|
501 (cond ((= ms 0) 'single)
|
|
|
502 ((= ms 1) 'several)
|
|
|
503 ((= ms 2) 'multi)
|
|
|
504 (t (error "ms losing")))
|
|
|
505 (cond ((= sp 0) 'nil)
|
|
|
506 ((= sp 1) 't)
|
|
|
507 (t (error "sp losing")))
|
|
|
508 )))
|
|
|
509
|
|
|
510 (defun energize-set-edit-modes (external-editor
|
|
|
511 terminal-emulator
|
|
|
512 internal-viewer
|
|
|
513 internal-editor
|
|
|
514 multi-screen-p
|
|
|
515 split-screens-p)
|
|
|
516 "Prompts for the various edit and view modes of Energize.
|
|
|
517
|
|
|
518 The \"external editor\" is the editor which Energize should use when
|
|
|
519 you ask it to edit a file. If you simply hit return, the files will
|
|
|
520 be edited in Lucid Emacs. The default for this is taken from the
|
|
|
521 environment variable $ENERGIZE_EXTERNAL_EDITOR.
|
|
|
522
|
|
|
523 If you specify \"vi\" as your external editor, then you will be asked
|
|
|
524 which terminal emulator window should be launched to run the vi (either
|
|
|
525 xterm, shelltool, or cmdtool.) The default for this is taken from the
|
|
|
526 environment variable $ENERGIZE_VI_WRAPPER.
|
|
|
527
|
|
|
528 Many of the Energize buffers (such as the Browsers) are not editable.
|
|
|
529 You have three choices for which keybindings you would like to use for
|
|
|
530 moving and searching around in those buffers: \"emacs\", \"vi\", or
|
|
|
531 \"less\" (which is a popular variant of \"more\"). The default for
|
|
|
532 this is taken from the environment variable $ENERGIZE_VIEW_MODE.
|
|
|
533
|
|
|
534 Some Energize buffers (such as the Project buffers) are editable, and
|
|
|
535 an external editor cannot be used on them. For these buffers, you have
|
|
|
536 a choice of either \"emacs\" or \"vi\" keybindings. The default for
|
|
|
537 this is taken from the environment variable $ENERGIZE_EDIT_MODE.
|
|
|
538
|
|
|
539 If you are not using an external editor, then specifying \"vi\" here
|
|
|
540 means that evi, the emacs vi emulator, will be used to edit your source
|
|
|
541 files as well.
|
|
|
542
|
|
|
543 You will also be asked whether Energize should automatically pop up multiple
|
|
|
544 windows (\"frames\" in emacs terminology) or should use and reuse one only
|
|
|
545 \(which is the traditional emacs model.) The default for this is taken from
|
|
|
546 the environment variable $ENERGIZE_MULTI_SCREEN_MODE.
|
|
|
547
|
|
|
548 Sometimes Energize wants to display two buffers at once, for example, the
|
|
|
549 Debugger buffer and the source file corresponding to the current stack frame.
|
|
|
550 You have two choices for how this should happen: one is to display the source
|
|
|
551 in the debugger frame, `splitting' the frame vertically, and the other is to
|
|
|
552 use two frames, one for the debugger and one for the source. The default for
|
|
|
553 this is taken from the envvironment variable $ENERGIZE_SPLIT_SCREENS_P."
|
|
|
554 ;; (interactive (energize-set-edit-modes-minibuf-prompt))
|
|
|
555 (interactive (energize-set-edit-modes-dbox-prompt))
|
|
|
556 (if (null terminal-emulator) (setq terminal-emulator 'xterm))
|
|
|
557 (if (equal energize-external-editor "emacs")
|
|
|
558 (setq energize-external-editor nil))
|
|
|
559
|
|
|
560 (or (null external-editor)
|
|
|
561 (stringp external-editor)
|
|
|
562 (signal 'wrong-type-argument (list 'stringp external-editor)))
|
|
|
563 (or (symbolp terminal-emulator)
|
|
|
564 (signal 'wrong-type-argument (list 'symbolp terminal-emulator)))
|
|
|
565 (or (symbolp internal-viewer)
|
|
|
566 (signal 'wrong-type-argument (list 'symbolp internal-viewer)))
|
|
|
567 (or (symbolp internal-editor)
|
|
|
568 (signal 'wrong-type-argument (list 'symbolp internal-editor)))
|
|
|
569 (or (memq split-screens-p '(t nil))
|
|
|
570 (error "split-screens-p must be t or nil"))
|
|
|
571
|
|
|
572 (cond ((equal external-editor "") (setq energize-external-editor nil))
|
|
|
573 ((equal external-editor "vi") (setq energize-external-editor 'vi))
|
|
|
574 (t (setq energize-external-editor external-editor)))
|
|
|
575
|
|
|
576 (if (eq internal-viewer 'emacs) (setq internal-viewer nil))
|
|
|
577 (if (eq internal-editor 'emacs) (setq internal-editor nil))
|
|
|
578 (setq energize-vi-terminal-emulator terminal-emulator)
|
|
|
579 (setq energize-internal-editor internal-editor)
|
|
|
580 (setq energize-internal-viewer internal-viewer)
|
|
|
581
|
|
|
582 (cond ((and (null energize-internal-viewer)
|
|
|
583 (null energize-internal-editor))
|
|
|
584 ;; Emacs all the way. They must be clueful.
|
|
|
585 ;; (remove-hook 'energize-disconnect-hook 'save-buffers-kill-emacs)
|
|
|
586 (setq pop-up-windows energize-split-screens-p))
|
|
|
587 (t
|
|
|
588 ;; (add-hook 'energize-disconnect-hook 'save-buffers-kill-emacs)
|
|
|
589 (setq pop-up-windows nil)))
|
|
|
590
|
|
|
591 (cond (energize-external-editor
|
|
|
592 (add-hook 'energize-disconnect-hook 'save-buffers-kill-emacs)
|
|
|
593 (energize-external-editor-set-menubar))
|
|
|
594 (t
|
|
|
595 (remove-hook 'energize-disconnect-hook 'save-buffers-kill-emacs)
|
|
|
596 (energize-internal-editor-set-menubar)))
|
|
|
597
|
|
|
598 (cond ;((eq multi-screen-p energize-screen-mode)
|
|
|
599 ; nil)
|
|
|
600 ((memq multi-screen-p '(t multi))
|
|
|
601 (energize-multi-screen-mode))
|
|
|
602 ((memq multi-screen-p '(nil single))
|
|
|
603 (energize-single-screen-mode))
|
|
|
604 ((memq multi-screen-p '(several))
|
|
|
605 (energize-several-screens-mode))
|
|
|
606 (t (error "multi-screen-p %S unrecognised" multi-screen-p)))
|
|
|
607
|
|
|
608 (setq energize-split-screens-p split-screens-p)
|
|
|
609
|
|
|
610 (let ((buffers (buffer-list)))
|
|
|
611 (save-excursion
|
|
|
612 (while buffers
|
|
|
613 (if (energize-buffer-p (car buffers))
|
|
|
614 (progn
|
|
|
615 (set-buffer (car buffers))
|
|
|
616 (normal-mode)
|
|
|
617 (energize-buffer-creation-hook-function (car buffers))))
|
|
|
618 (setq buffers (cdr buffers)))))
|
|
|
619 (setq energize-edit-modes-specified t)
|
|
|
620 nil)
|
|
|
621
|
|
|
622 (defun energize-hack-external-editor-mode ()
|
|
|
623 (if energize-edit-modes-specified
|
|
|
624 nil
|
|
|
625 (condition-case c
|
|
|
626 (let ((ee (getenv "ENERGIZE_EXTERNAL_EDITOR"))
|
|
|
627 (te (getenv "ENERGIZE_VI_WRAPPER"))
|
|
|
628 (iv (getenv "ENERGIZE_VIEW_MODE"))
|
|
|
629 (ie (getenv "ENERGIZE_EDIT_MODE"))
|
|
|
630 (ms (getenv "ENERGIZE_MULTI_SCREEN_MODE"))
|
|
|
631 (sp (getenv "ENERGIZE_SPLIT_SCREENS_P"))
|
|
|
632 )
|
|
|
633 (if (member ee '("" nil)) (setq ee nil))
|
|
|
634 (if (member te '("" nil)) (setq te "xterm"))
|
|
|
635 (if (member iv '("" nil)) (setq iv "emacs"))
|
|
|
636 (if (member ie '("" nil)) (setq ie "emacs"))
|
|
|
637 (if (member sp '("" nil)) (setq sp "yes"))
|
|
|
638 (if ms (setq ms (downcase ms)))
|
|
|
639 (setq sp (downcase sp))
|
|
|
640 (let ((standard-output (function external-debugging-output)))
|
|
|
641 (if (member te '("xterm" "shelltool" "cmdtool"))
|
|
|
642 nil
|
|
|
643 (princ (format
|
|
|
644 "$ENERGIZE_VI_WRAPPER is %S, not xterm, shelltool, or cmdtool.\n" te))
|
|
|
645 (setq te nil))
|
|
|
646 (if (member iv '("emacs" "vi" "less"))
|
|
|
647 nil
|
|
|
648 (princ (format
|
|
|
649 "$ENERGIZE_VIEW_MODE is %S, not emacs, vi, or less.\n"
|
|
|
650 iv))
|
|
|
651 (setq iv nil))
|
|
|
652 (if (member ie '("emacs" "vi" "less"))
|
|
|
653 nil
|
|
|
654 (princ (format
|
|
|
655 "$ENERGIZE_EDIT_MODE is %S, not emacs or vi.\n" ie))
|
|
|
656 (setq ie nil))
|
|
|
657 (cond ((member ms '("yes" "y" "true" "on" "1" "" "multi" "many"
|
|
|
658 "often"))
|
|
|
659 (setq ms 'multi))
|
|
|
660 ((member ms '("no" "n" "false" "off" "0" "single"
|
|
|
661 "never"))
|
|
|
662 (setq ms 'single))
|
|
|
663 ((member ms '("several" "some" "few" "sometimes"))
|
|
|
664 (setq ms 'several))
|
|
|
665 (t
|
|
|
666 (if ms
|
|
|
667 (princ
|
|
|
668 (format
|
|
|
669 "$ENERGIZE_MULTI_SCREEN_MODE was %S, not often, sometimes, or never\n"
|
|
|
670 ms)))
|
|
|
671 (setq ms (or energize-screen-mode
|
|
|
672 (if (and (null ee)
|
|
|
673 (equal iv "emacs")
|
|
|
674 (equal ie "emacs"))
|
|
|
675 'single
|
|
|
676 'multi)))))
|
|
|
677 (cond ((member sp '("yes" "y" "true" "on" "1" ""))
|
|
|
678 (setq sp t))
|
|
|
679 ((member sp '("no" "n" "false" "off" "0"))
|
|
|
680 (setq sp nil))
|
|
|
681 (t
|
|
|
682 (princ
|
|
|
683 (format "$ENERGIZE_SPLIT_SCREENS_P was %S, not a boolean.\n"
|
|
|
684 sp))))
|
|
|
685 )
|
|
|
686 (energize-set-edit-modes ee (intern te) (intern iv) (intern ie) ms sp)
|
|
|
687 )
|
|
|
688 ;; condition-case
|
|
|
689 (error
|
|
|
690 (let ((standard-output (function external-debugging-output)))
|
|
|
691 (princ "Internal error: %S\n" c))))))
|
|
|
692
|
|
|
693
|
|
|
694 ;;; Make the buffers menu say "view file" if in external-editor mode
|
|
|
695 ;;; Originally defined in menubar.el
|
|
|
696
|
|
|
697 (defun format-buffers-menu-line (buffer)
|
|
|
698 "Returns a string to represent the given buffer in the Buffer menu.
|
|
|
699 nil means the buffer shouldn't be listed. You can redefine this."
|
|
|
700 (if (string-match "\\` " (setq buffer (buffer-name buffer)))
|
|
|
701 nil
|
|
|
702 (if energize-external-editor
|
|
|
703 (concat
|
|
|
704 ; (if (buffer-file-name (get-buffer buffer))
|
|
|
705 ; "View File "
|
|
|
706 ; "View Buffer ")
|
|
|
707 "View "
|
|
|
708 buffer)
|
|
|
709 buffer)))
|
