Mercurial > hg > xemacs-beta
comparison lisp/energize/energize-vi.el @ 0:376386a54a3c r19-14
Import from CVS: tag r19-14
| author | cvs |
|---|---|
| date | Mon, 13 Aug 2007 08:45:50 +0200 |
| parents | |
| children | 131b0175ea99 |
comparison
equal
deleted
inserted
replaced
| -1:000000000000 | 0:376386a54a3c |
|---|---|
| 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) | |
| 229 (message (format "%s" output))) | |
| 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))) |