I'm another one of the people who had been successfully using jde 2.2.7.1 and
decided to upgrade to 2.2.9beta4 with the latest of each of the other packages (all
downloaded yesterday). I try to compile a simple standalone program. I am not
using a prj.el file. Running xemacs 21.4.
I get a compile error in the bean shell. Took forever to figure out how to view my
message buffer (show-message-log) and see what it was complaining about.
As soon as I had loaded my java file, I set variable jde-compile-option-directory to
the
directory where the source itself is located and then did a compile.
Here's the buffer:
Loading recent-files...
Loading recent-files...done
Loading c:\joe\.recent-files.el...
Loading c:\joe\.recent-files.el...done
Loading cus-face...
Loading cus-face...done
Loading cl-macs...
Loading cl-macs...done
Bootstrapping objects...
Bootstrapping objects...done
ECB uses semantic 1.4beta11 and eieio 0.17beta3
Loading edmacro...
Loading edmacro...done
Loading efs-cu...
Loading efs-cu...done
Loading jde...
Loading customization dependencies...
Loading customization dependencies...done
Loading regexp-opt...
Loading regexp-opt...done
jde-java-font-lock: building names cache...
jde-java-font-lock: building names cache...empty
Loading jde...done
Loading lazy-lock...
Loading lazy-lock...done
Setting JDE variables to startup values...
Loading timer...
Quit
Loading timer...done
Starting the BeanShell. Please wait...
Beanshell expression evaluation error.
Expression: jde.util.JdeUtilities.setProjectValues("", "");
Error: // Error: bsh.EvalError: Error in method invocation: Method
setProjectValues(java.lang.String, java.lang.String) not found in
class'jde.util.JdeUtilities' : jde .util .JdeUtilities .setProjectValues ( "" , "" )
Beanshell eval error. See messages buffer for details.
Any idea what is wrong?? I'm enclosing my init.el and custom.el below.
Thanks in advance for any direction,
Joe
init.el ==>
;; recent-files
(load "recent-files")
(recent-files-initialize)
(setq load-path (nconc '(
"C:/Joe/lisp"
; "C:/Joe/lisp/jde-2.2.7.1/lisp"
; "C:/Joe/lisp/semantic-1.4beta6"
; "C:/Joe/lisp/eieio-0.16"
; "C:/Joe/lisp/speedbar-0.13a"
; "C:/Joe/lisp/ecb-1.31"
"C:/Joe/lisp/jde-2.2.9beta4/lisp"
"C:/Joe/lisp/semantic-1.4beta11"
"C:/Joe/lisp/eieio-0.17beta3"
"C:/Joe/lisp/speedbar-0.4beta1"
"C:/Joe/lisp/ecb-1.52"
) load-path))
;; gnus
(setq gnus-select-method '(nntp "news.dsli.net"))
(setq gnus-subscribe-hierarchical-interactive t)
(setq gnus-default-subscribed-newsgroup t)
(setq user-mail-address "[EMAIL PROTECTED]")
(setq gnus-check-new-newsgroups 'ask-server)
(setq gnus-save-killed-list nil)
;; custom commands
(global-set-key [f1] 'set-mark-command)
(global-set-key [f2] 'copy-region-as-kill)
(global-set-key [f3] 'isearch-forward)
(global-set-key [f4] 'isearch-backward)
(global-set-key [f5] 'replace-string)
(global-set-key [f6] 'query-replace)
(global-set-key [f7] 'backward-word)
(global-set-key [f8] 'forward-word)
(global-set-key [f9] 'kill-word)
(global-set-key [f10] 'kill-region)
(global-set-key [f11] 'back-to-indentation)
(global-set-key [f12] 'fill-paragraph)
(global-set-key [SunF37] 'fill-paragraph)
(global-set-key [home] 'beginning-of-line)
(global-set-key [end] 'end-of-line)
(global-set-key [delete] 'delete-char)
(global-set-key [pause] 'where-is)
(global-set-key [cancel] 'describe-function)
(global-set-key [print] 'describe-key)
;; Make Ctl-\ the goto-line key, etc
(global-set-key "\C-\\" 'goto-line)
(global-set-key "\C-/" 'what-line)
;;(global-set-key [C-9] 'start-kbd-macro)
;;(global-set-key [C-0] 'end-kbd-macro)
;;(global-set-key [C-.] 'call-last-kbd-macro)
;; C, C++, Java stuff
;; This adds additional extensions which indicate files normally
;; handled by cc-mode.
(setq auto-mode-alist
(append '(("\\.C$" . c++-mode)
("\\.cc$" . c++-mode)
("\\.hh$" . c++-mode)
("\\.c$" . c-mode)
("\\.h$" . c-mode)
)
auto-mode-alist))
;; Tell cc-mode not to check for old-style (K&R) function declarations.
;; This speeds up indenting a lot.
(setq c-recognize-knr-p nil)
(defconst my-c-style
'(
(c-auto-newline . nil)
(c-indent-level . 4)
(c-continued-statement-offset . 4)
(c-continued-brace-offset . 0)
(c-brace-offset . 0)
(c-brace-imaginary-offset . 0)
(c-argdecl-indent . 6)
(c-label-offset . -2)
(c-tab-always-indent . true)
(c-comment-only-line-offset . 4)
(c-hanging-braces-alist . ((substatement-open after)
(brace-list-open)))
(c-hanging-colons-alist . ((member-init-intro before)
(inher-intro)
(case-label after)
(label after)
(access-label after)))
(c-cleanup-list . (scope-operator
empty-defun-braces
defun-close-semi))
(c-offsets-alist . ((arglist-close . c-lineup-arglist)
(substatement-open . 0)
(case-label . 4)
(block-open . 0)
(knr-argdecl-intro . -)))
(c-echo-semantic-information-p . t)
)
"My C Programming Style")
(setq default-tab-width 4)
(setq tab-width 4)
;; Customizations for both c-mode and c++-mode, etc
(defun my-c-mode-common-hook ()
;; set up for my perferred indentation style and set it for current buffer
(c-add-style "PERSONAL" my-c-style t)
;; offset customizations not in my-c-sytle
(c-set-offset 'substatement-open 0)
(c-set-offset 'inline-open 0)
;; this will make sure spaces are used instead of tabs
(define-key c-mode-base-map "\C-m" 'newline-and-indent)
)
(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
;; Here we define our own function and then bind a key to it.
(defun start-or-end-kbd-macro ()
;; A doc string. This is optional.
"Start defining a keyboard macro, or stop if we're already defining."
;; IMPORTANT: Any function bound to a key MUST have an interactive spec,
;; usually just the following line:
(interactive)
(if defining-kbd-macro
(end-kbd-macro)
(start-kbd-macro nil)))
;; The macros used to have their place in the function keys, but I
;; find that I use them significantly less than the really basic
;; things on the function keys. When using a macro, you call the
;; macro much more than define it, so the setup below makes some
;; sense.
(global-set-key '(shift kp-multiply) 'start-or-end-kbd-macro)
(global-set-key 'kp-multiply 'call-last-kbd-macro) ;; C-x e
;;;;;;;;;;;;;;;;;;;;;;;;
;; Keystrokes to conveniently switch buffers.
;; F6 is invaluable for flipping back and forth between two buffers
;; you're working with.
(global-set-key 'f6 'switch-to-other-buffer) ;; M-C-l
(global-set-key '(meta n) 'switch-to-next-buffer-in-group)
(global-set-key '(meta p) 'switch-to-previous-buffer-in-group)
(global-set-key '(meta N) 'switch-to-next-buffer)
(global-set-key '(meta P) 'switch-to-previous-buffer)
;; Define our own function to deal with the possibility that the newer
;; stuff in the gutter code may not be present -- i.e. we're running
;; an older XEmacs. Note that we avoid trying to "helpfully" define a
;; function that is present in new versions of XEmacs, but not in
;; older ones. That can very easily screw up code trying to determine
;; what functionality is present using `fboundp' checks. See above,
;; near `emacs-version>=', for a full discussion of this.
(defun Init-buffers-tab-omit (buf)
;; a function specifying the buffers to omit from the buffers tab.
;; This is passed a buffer and should return non-nil if the buffer
;; should be omitted. If the standard buffers-tab functionality is
;; there, we just call it to do things "right". Otherwise we just
;; omit invisible buffers, snarfing the code from
;; `buffers-menu-omit-invisible-buffers'.
(if (boundp 'buffers-tab-omit-function)
(funcall buffers-tab-omit-function buf)
(not (null (string-match "\\` " (buffer-name buf))))))
(defun switch-to-next-buffer (&optional n)
"Switch to the next-most-recent buffer.
This essentially rotates the buffer list forward.
N (interactively, the prefix arg) specifies how many times to rotate
forward, and defaults to 1. Buffers whose name begins with a space
\(i.e. \"invisible\" buffers) are ignored."
;; Here is a different interactive spec. Look up the function
;; `interactive' (i.e. `C-h f interactive') to understand how this
;; all works.
(interactive "p")
(dotimes (n (or n 1))
(loop
do (bury-buffer (car (buffer-list)))
while (Init-buffers-tab-omit (car (buffer-list))))
(switch-to-buffer (car (buffer-list)))))
(defun buffers-menu-omit-invisible-buffers (buf)
"For use as a value of `buffers-menu-omit-function'.
Omits normally invisible buffers (those whose name begins with a space)."
(not (null (string-match "\\` " (buffer-name buf)))))
(defvar Init-buffers-tab-grouping-regexp
'("^\\(gnus-\\|message-mode\\|mime/viewer-mode\\)"
"^\\(emacs-lisp-\\|lisp-\\)")
;; If non-nil, a list of regular expressions for buffer grouping.
;; Each regular expression is applied to the current major-mode symbol
;; name and mode-name, if it matches then any other buffers that match
;; the same regular expression be added to the current group. This is
;; a copy of `buffers-tab-grouping-regexp'.
)
(defun Init-select-buffers-tab-buffers (buffer-to-select buf1)
;; Specifies the buffers to select from the buffers tab. This is
;; passed two buffers and should return non-nil if the second buffer
;; should be selected. If the standard buffers-tab functionality is
;; there, we just call it to do things "right". Otherwise, we group
;; buffers by major mode and by `Init-buffers-tab-grouping-regexp'.
;; [We've copied `select-buffers-tab-buffers-by-mode' and
;; `buffers-tab-grouping-regexp'.]
(if (boundp 'buffers-tab-selection-function)
(funcall buffers-tab-selection-function buffer-to-select buf1)
(let ((mode1 (symbol-name (symbol-value-in-buffer 'major-mode buf1)))
(mode2 (symbol-name (symbol-value-in-buffer 'major-mode
buffer-to-select)))
(modenm1 (symbol-value-in-buffer 'mode-name buf1))
(modenm2 (symbol-value-in-buffer 'mode-name buffer-to-select)))
(cond ((or (eq mode1 mode2)
(eq modenm1 modenm2)
(and (string-match "^[^-]+-" mode1)
(string-match
(concat "^" (regexp-quote
(substring mode1 0 (match-end 0))))
mode2))
(and Init-buffers-tab-grouping-regexp
(find-if #'(lambda (x)
(or
(and (string-match x mode1)
(string-match x mode2))
(and (string-match x modenm1)
(string-match x modenm2))))
Init-buffers-tab-grouping-regexp)))
t)
(t nil)))))
(defun switch-to-previous-buffer (&optional n)
"Switch to the previously most-recent buffer.
This essentially rotates the buffer list backward.
N (interactively, the prefix arg) specifies how many times to rotate
backward, and defaults to 1. Buffers whose name begins with a space
\(i.e. \"invisible\" buffers) are ignored."
(interactive "p")
(dotimes (n (or n 1))
(loop
do (switch-to-buffer (car (last (buffer-list))))
while (Init-buffers-tab-omit (car (buffer-list))))))
(defun switch-to-next-buffer-in-group (&optional n)
"Switch to the next-most-recent buffer in the current group.
This essentially rotates the buffer list forward.
N (interactively, the prefix arg) specifies how many times to rotate
forward, and defaults to 1. Buffers whose name begins with a space
\(i.e. \"invisible\" buffers) are ignored."
(interactive "p")
(dotimes (n (or n 1))
(let ((curbuf (car (buffer-list))))
(loop
do (bury-buffer (car (buffer-list)))
while (or (Init-buffers-tab-omit (car (buffer-list)))
(not (Init-select-buffers-tab-buffers
curbuf (car (buffer-list)))))))
(switch-to-buffer (car (buffer-list)))))
(defun switch-to-previous-buffer-in-group (&optional n)
"Switch to the previously most-recent buffer in the current group.
This essentially rotates the buffer list backward.
N (interactively, the prefix arg) specifies how many times to rotate
backward, and defaults to 1. Buffers whose name begins with a space
\(i.e. \"invisible\" buffers) are ignored."
(interactive "p")
(dotimes (n (or n 1))
(let ((curbuf (car (buffer-list))))
(loop
do (switch-to-buffer (car (last (buffer-list))))
while (or (Init-buffers-tab-omit (car (buffer-list)))
(not (Init-select-buffers-tab-buffers
curbuf (car (buffer-list)))))))))
;;;;;;;;;;;;;;;;;;;;;;;;
;; Other text keystrokes.
;; Make a keystroke to insert a literal TAB character. (`C-q TAB' is
;; annoying because difficult to repeat.) Note that this does not work
;; in TTY frames, where TAB and Shift-TAB are indistinguishable.
(define-key global-map '(shift tab) 'tab-to-tab-stop)
;; When not on a TTY, remove the binding of C-x C-c, which normally
;; exits XEmacs. It's easy to hit this by mistake, and that can be
;; annoying. You can always quit with the "Exit XEmacs" option on the
;; File menu.
(when (console-on-window-system-p)
(global-set-key "\C-x\C-c" nil))
;; When not on a TTY, remove the binding of C-x C-c, which normally
;; exits XEmacs. It's easy to hit this by mistake, and that can be
;; annoying. You can always quit with the "Exit XEmacs" option on the
;; File menu.
(when (console-on-window-system-p)
(global-set-key "\C-x\C-c" nil))
;; When not on a TTY, remove the binding of C-x C-c, which normally
;; exits XEmacs. It's easy to hit this by mistake, and that can be
;; annoying. You can always quit with the "Exit XEmacs" option on the
;; File menu.
(when (console-on-window-system-p)
(global-set-key "\C-x\C-c" nil))
;; Enable obvious hyperlink following with button1.
(setq Info-button1-follows-hyperlink t)
;; When running ispell, consider all 1-3 character words as correct.
(setq ispell-extra-args '("-W" "3"))
;; Enable line numbers and column numbers. This is done in C code now
;; and is very fast.
(line-number-mode 1)
(column-number-mode 1)
;;; ********************
;;; Load the default-dir.el package which installs fancy handling of
;;; the initial contents in the minibuffer when reading file names.
;(condition-case nil
; (require 'default-dir)
; (error nil))
;;; ********************
;;; lazy-lock is a package which speeds up the highlighting of files
;;; by doing it "on-the-fly" -- only the visible portion of the
;;; buffer is fontified. The results may not always be quite as
;;; accurate as using full font-lock or fast-lock, but it's *much*
;;; faster. No more annoying pauses when you load files.
(add-hook 'font-lock-mode-hook 'turn-on-lazy-lock)
;; I personally don't like "stealth mode" (where lazy-lock starts
;; fontifying in the background if you're idle for 30 seconds)
;; because it takes too long to wake up again on my piddly Sparc 1+.
(setq lazy-lock-stealth-time nil)
;;;;;;;;;;;;;;;;;;;;;;;;
;; Useful programming-related keystrokes.
(defun describe-foo-at-point ()
"Show the documentation of the Elisp function and variable near point.
This checks in turn:
-- for a function name where point is
-- for a variable name where point is
-- for a surrounding function call
"
(interactive)
(let (sym)
;; sigh, function-at-point is too clever. we want only the first half.
(cond ((setq sym (ignore-errors
(with-syntax-table emacs-lisp-mode-syntax-table
(save-excursion
(or (not (zerop (skip-syntax-backward "_w")))
(eq (char-syntax (char-after (point))) ?w)
(eq (char-syntax (char-after (point))) ?_)
(forward-sexp -1))
(skip-chars-forward "`'")
(let ((obj (read (current-buffer))))
(and (symbolp obj) (fboundp obj) obj))))))
(describe-function sym))
((setq sym (variable-at-point)) (describe-variable sym))
;; now let it operate fully -- i.e. also check the
;; surrounding sexp for a function call.
((setq sym (function-at-point)) (describe-function sym)))))
(global-set-key '(shift f4) 'next-error) ;; C-x `
(global-set-key '(control f4) 'previous-error)
(global-set-key '(shift f5) 'find-library)
(global-set-key '(control f5) 'find-function)
(global-set-key '(meta f5) 'find-variable)
(global-set-key '(shift f11) 'describe-foo-at-point)
(global-set-key '(control f11) 'eval-last-sexp)
;; Edebug is a source-level debugger for Emacs Lisp programs. Put
;; the cursor at the end of a function definition and "instrument" it
;; with this command; then, you can single step through it the next
;; time it's run.
(global-set-key '(meta f11) 'edebug-defun)
(global-set-key '(meta f12) 'add-change-log-entry)
;; This nicely parallels M-*, which pops the tag stack. See below for
;; how to set up tags.
(global-set-key '(control *) 'find-tag-at-point)
;; Define a function to conveniently determine where time is being
;; spent when executing commands or Lisp code.
(defun toggle-profiling ()
"Start profiling, or stop it and print results.
This lets you figure out where time is being spent when executing Lisp code."
(interactive)
(if (profiling-active-p)
(progn
(stop-profiling)
(message "...Finished profiling")
(profile-results))
(message "Profiling...")
(clear-profiling-info)
(start-profiling)))
;; Note that sequences of C-c plus a letter are specifically
;; reserved for users and should never be bound by any packages.
(global-set-key "\C-cp" 'toggle-profiling)
;; LISPM bindings of Control-Shift-C and Control-Shift-E.
;; See comment above about bindings like this.
(define-key emacs-lisp-mode-map '(control C) 'compile-defun)
(define-key emacs-lisp-mode-map '(control E) 'eval-defun)
;;;;;;;;;;;;;;;;;;;;;;;;
;; Numeric keypad.
;; The numeric keypad as a whole is underused, and it's a good source
;; of keys to bind to commands. Here we add some useful bindings.
;; Because this is a sample file and I want to avoid unpleasant
;; surprises for novices, I don't actually bind the shared
;; numeric/cursor-motion keys because
;;
;; (a) someone keypads don't have separate motion keys (e.g. laptops?), and
;; (b) TTY's and some X servers might not distinguish the regular and
;; numeric-keypad motion keys.
;; `kill-current-buffer' (defined below) deletes the current
;; buffer. (Don't worry, you will be prompted to save if it's
;; modified.) By repeatedly pressing keypad-minus, you can
;; conveniently reduce the number of open buffers to a manageable size
;; after you've opened a whole bunch of files and finished working on
;; them. Shift plus keypad-minus kills both the current buffer and
;; its window, and Control plus keypad-minus kills just the current
;; window.
(global-set-key 'kp-subtract 'kill-current-buffer)
(global-set-key '(shift kp-subtract) 'kill-current-buffer-and-window)
(global-set-key '(control kp-subtract) 'delete-window)
;; Ugh, modes that use `suppress-keymap' and are dumped with XEmacs will
;; need their own definition. There is no easy way to fix this.
(define-key help-mode-map 'kp-subtract 'kill-current-buffer)
(define-key help-mode-map '(shift kp-subtract)
'kill-current-buffer-and-window)
(define-key list-mode-map 'kp-subtract 'kill-current-buffer)
(define-key list-mode-map '(shift kp-subtract)
'kill-current-buffer-and-window)
(defun kill-current-buffer ()
"Kill the current buffer (prompting if it is modified)."
(interactive)
(kill-buffer (current-buffer)))
(defun kill-current-buffer-and-window ()
"Kill the current buffer (prompting if it is modified) and its window."
(interactive)
(kill-buffer (current-buffer))
(delete-window))
(defvar grep-all-files-history nil)
(defvar grep-all-files-omitted-expressions
'("*~" "#*" ".#*" ",*" "*.elc" "*.obj" "*.o" "*.exe" "*.dll" "*.lib" "*.a"
"*.dvi" "*.class" "*.bin")
"List of expressions matching files to be omitted in `grep-all-files-...'.
Each entry should be a simple name or a shell wildcard expression.")
(defvar grep-all-files-omitted-directories '("CVS" "RCS" "SCCS")
"List of directories not to recurse into in `grep-all-files-...'.
Each entry should be a simple name or a shell wildcard expression.")
(defun construct-grep-all-files-command (find-segment grep-segment)
(let ((omit-annoying
(mapconcat #'(lambda (wildcard)
(concat "-name '" wildcard "' -or "))
grep-all-files-omitted-expressions
"")))
(cond ((eq grep-find-use-xargs 'gnu)
(format "find . %s %s -type f -print0 | xargs -0 -e %s"
find-segment omit-annoying grep-segment))
(grep-find-use-xargs
(format "find . %s %s -type f -print | xargs %s"
find-segment omit-annoying grep-segment))
(t
(format "find . %s %s -type f -exec %s {} /dev/null \\;"
find-segment omit-annoying grep-segment)))))
(defun grep-all-files-in-current-directory (command)
"Run `grep' in all non-annoying files in the current directory.
`Non-annoying' excludes backup files, autosave files, CVS merge files, etc.
More specifically, this is controlled by `grep-all-files-omitted-expressions'.
This function does not recurse into subdirectories. If you want this,
use \\[grep-all-files-in-current-directory-and-below]."
(interactive
(progn
(require 'compile)
(list (read-shell-command "Run grep (like this): "
grep-command 'grep-all-files-history))))
(require 'compile)
(grep (construct-grep-all-files-command
"-name . -or -type d -prune -or" command)))
(defun grep-all-files-in-current-directory-and-below (command)
"Run `grep' in all non-annoying files in the current directory and below.
`Non-annoying' excludes backup files, autosave files, CVS merge files, etc.
More specifically, this is controlled by `grep-all-files-omitted-expressions'.
This function recurses into subdirectories. If you do not want this,
use \\[grep-all-files-in-current-directory]."
(interactive
(progn
(require 'compile)
(list (read-shell-command "Run grep (like this): "
grep-command 'grep-all-files-history))))
(require 'compile)
(grep (construct-grep-all-files-command
;; prune all specified directories.
(mapconcat #'(lambda (wildcard)
(concat "-name '" wildcard "' -prune -or "))
grep-all-files-omitted-directories
"")
command)))
(defun clear-select ()
"Repeatedly select ever larger balanced expressions around the cursor.
Once you have such an expression marked, you can expand to the end of
the following expression with \\[mark-sexp] and to the beginning of the
previous with \\[backward-sexp]."
(interactive "_") ;this means "preserve the active region after this command"
(backward-up-list 1)
(let ((end (save-excursion (forward-sexp) (point))))
(push-mark end nil t)))
;; #### no kp-divide because it doesn't (currently) work on MS Windows
;; -- always reports as /. #### this should be fixable.
(global-set-key 'kp-add 'query-replace)
(global-set-key '(shift kp-add) 'query-replace-regexp)
(global-set-key '(control kp-add) 'grep-all-files-in-current-directory)
(global-set-key '(meta kp-add) 'grep-all-files-in-current-directory-and-below)
(global-set-key 'clear 'clear-select)
;; Note that you can use a "lambda" expression (an anonymous function)
;; in place of a function name. This function would be called
;; `pop-local-mark' and lets you repeatedly cycle back through recent
;; marks (marks are set whenever you begin a selection, begin a
;; successful search, are about to jump to the beginning or end of the
;; buffer, etc.).
(global-set-key 'kp-enter (lambda () (interactive) (set-mark-command t)))
(global-set-key '(shift kp-enter) 'repeat-complex-command)
(global-set-key 'pause 'repeat-complex-command) ;; useful on Windows-style kbds
(global-set-key '(control kp-enter) 'eval-expression)
;; Rearrange the modeline so that everything is to the left of the
;; long list of minor modes, which is relatively unimportant but takes
;; up so much room that anything to the right is obliterated.
(setq-default
modeline-format
(list
""
(if (boundp 'modeline-multibyte-status) 'modeline-multibyte-status "")
(cons modeline-modified-extent 'modeline-modified)
(cons modeline-buffer-id-extent
(list (cons modeline-buffer-id-left-extent
(cons 15 (list
(list 'line-number-mode "L%l ")
(list 'column-number-mode "C%c ")
(cons -3 "%p"))))
(cons modeline-buffer-id-right-extent "%17b")))
" "
'global-mode-string
" %[("
(cons modeline-minor-mode-extent
(list "" 'mode-name 'minor-mode-alist))
(cons modeline-narrowed-extent "%n")
'modeline-process
")%]----"
"%-"
))
;; Get rid of modeline information taking up too much space -- in
;; particular, minor modes that are always enabled.
(setq pending-delete-modeline-string "")
(setq filladapt-mode-line-string "")
;; lazy-lock doesn't have a variable for its modeline name, so we have
;; to do a bit of surgery.
(and (assoc 'lazy-lock-mode minor-mode-alist)
(setcdr (cdr (cadr (assoc 'lazy-lock-mode minor-mode-alist))) ""))
;; enable ecb
(require 'ecb)
And here is my custom.el ==>
(custom-set-variables
'(recent-files-permanent-submenu t)
'(recent-files-commands-submenu t)
'(recent-files-number-of-entries 25)
'(visible-bell t)
'(recent-files-include-save-now t)
)
(custom-set-faces)
---
Joe Berry
[EMAIL PROTECTED]
AIM "joe topshot"
Yahoo Msgr "joetopshot"
Baltimore, MD
