At 12:54 PM 7/11/00 -0500, you wrote:
>I just upgraded to JDE 2.1.9 and it obviously broke my customization of
supporting a list of regular expressions for the
jde-wiz-insert-excluded-packages-regexp
>customizable variable. (Is there some way of having an "or list" in the
regexp? I don't know of a way, and that's why I want the list...besides
the list is
>easier to edit ;^).
>
>Anyway, I understand not wanting to break existing code. So I created a
new customizable variable called
jde-wiz-insert-excluded-packages-regexp-list which is a
>list of regexps. I then modified the code so that
jde-wiz-strip-excluded-imports excludes for both variables.
>
Is there any reason for having both of these variables other than
preserving existing prj.el files. The list variable seems to include the
non-list variable. So why not just have a list of regexps for classes to
exclude?
- Paul
>I also made a fix to the jde-wiz-choose-imports function so that it works
correctly if pop-up-windows is set to nil (I use that setting, and JDE was
improperly
>deleting my windows). The following is the updated jde-wiz.el file:
>
>;;; jde-wiz.el
>;; $Revision: 1.23 $
>
>;; Author: Paul Kinnucan <[EMAIL PROTECTED]>
>;; Maintainer: Paul Kinnucan
>;; Keywords: java, tools
>
>;; Copyright (C) 1997, 1998 Paul Kinnucan.
>
>;; GNU Emacs is free software; you can redistribute it and/or modify
>;; it under the terms of the GNU General Public License as published by
>;; the Free Software Foundation; either version 2, or (at your option)
>;; any later version.
>
>;; GNU Emacs is distributed in the hope that it will be useful,
>;; but WITHOUT ANY WARRANTY; without even the implied warranty of
>;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>;; GNU General Public License for more details.
>
>;; You should have received a copy of the GNU General Public License
>;; along with GNU Emacs; see the file COPYING. If not, write to the
>;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
>;; Boston, MA 02111-1307, USA.
>
>(require 'beanshell)
>
>;; begin JVL enhancement contributed by Jim LoVerde <[EMAIL PROTECTED]>
>(defcustom jde-wiz-insert-excluded-packages-regexp-list '("bsh.*")
> "*Specifies classes that should not be imported into a source file.
>The value of this variable should be a regular expression. The
`jde-wiz-find-and-import' command does not import any classes whose fully
qualified names matchthe
>regular expression. If more than one fully qualified class name matches
theunqualified name that you specify, the command prompts you to select
only the classes
>that do not match the regular expression."
> :group 'jde-project
> :type '(repeat (string :tag "Command")))
>;; end JVL enhancement contributed by Jim LoVerde <[EMAIL PROTECTED]>
>
>(defcustom jde-wiz-insert-excluded-packages-regexp "bsh.*"
> "*Specifies classes that should not be imported into a source file.
>The value of this variable should be a regular expression. The
`jde-wiz-find-and-import' command does not import any classes whose fully
qualified names matchthe
>regular expression. If more than one fully qualified class name matches
theunqualified name that you specify, the command prompts you to select
only the classes
>that do not match the regular expression."
> :group 'jde-project
> :type 'string)
>
>(defun jde-wiz-update-class-list()
> "Update the class list used to resolve class names.
>The first time you invoke a JDE wizard, the JDE builds a list of all
classes on the classpath
>defined by jde-global-classpath. Wizards use this list to resolve
unqualified class names. If you add any classes to the classpath after
invoking a wizard, you
>should update the class list."
> (interactive)
> (message "Rescanning classes..." )
> (bsh-eval "jde.util.JdeUtilities.buildClassList();" )
> (message "Rescanning classes...Complete"))
>
>
>(defun jde-wiz-get-imports()
> (let ((import-re "import[ ]+\\(.*\\)[ ]*;")
> (imports nil))
> (save-excursion
> (goto-char (point-max))
> (while (re-search-backward import-re (point-min) t)
> (looking-at import-re)
> (setq imports (nconc imports
> (list (buffer-substring-no-properties
> (match-beginning 1)
> (match-end 1)))))))
> imports))
>
>(defun jde-wiz-get-package-name ()
> (let ((package-re "package[ \t]+\\(.*\\)[ \t]*;"))
> (save-excursion
> (goto-char (point-max))
> (when (re-search-backward package-re (point-min) t)
> (looking-at package-re)
> (buffer-substring-no-properties
> (match-beginning 1)
> (match-end 1))))))
>
>(defun jde-wiz-get-import-insertion-point ()
> (let ((ip-re
> (list (cons "import[ ]+\\(.*\\)[ ]*;" 'backward)
> (cons "package[ \t]+\\(.*\\)[ \t]*;" 'backward)
> (cons "^$" 'forward)))
> insertion-point n)
> (save-excursion
> (let ((i 0)
> (n (length ip-re)))
> (while (and
> (not insertion-point)
> (< i n))
> (let ((re (car (nth i ip-re)))
> (direction (cdr (nth i ip-re))))
> (if (eq direction 'forward)
> (progn
> (goto-char (point-min))
> (setq insertion-point (re-search-forward re (point-max) t)))
> (goto-char (point-max))
> (setq insertion-point (re-search-backward re (point-min) t)))
> (when insertion-point
> (forward-line 1)
> (setq insertion-point (point))))
> (setq i (+ i 1)))))
> insertion-point))
>
>
>(defun jde-wiz-import (class)
> "*Insert an import statement for a class in the current buffer.
>CLASS is the fully qualified name of the class to be imported. This
>function allows you to enter an import at the head of your buffer
>from any point in the buffer. The function does nothing if an import
>statement for the specified class alrady exists."
> (interactive
> "sClass: ")
> (jde-wiz-insert-imports (list class)))
>
>;; Contributed by David Ponce <[EMAIL PROTECTED]>
>(defun jde-sort-imports (&optional reverse)
> "Sort Java import statements alphabetically. In reverse order if
>REVERSE is non-nil.
>
>Usage:
> \\[jde-sort-imports] sort import statements ascending.
> \\[universal-argument] \\[jde-sort-imports] sort descending.
>
>The the current buffer must be in `jde-mode'. This command uses the
>semantic Java parser and requires JDE 2.1.6-beta24 and above."
> (interactive "P")
> (or (eq major-mode 'jde-mode)
> (error "Invalid major mode found. Must be 'jde-mode'."))
> (or (and (local-variable-p 'semantic-toplevel-bovine-table
(current-buffer))
> (symbol-value 'semantic-toplevel-bovine-table))
> (error "Semantic Java parser not found. JDE 2.1.6-beta24+
>needed."))
> (and (interactive-p)
> (consp current-prefix-arg)
> (setq reverse t))
> (let* ((tokens (semantic-bovinate-toplevel nil nil t))
> (depends (semantic-find-nonterminal-by-token 'include tokens)))
> (if depends
> (let* ((first-import-token (car depends))
> (last-import-token (nth (1- (length depends)) depends))
> (start (semantic-token-start first-import-token))
> (end (semantic-token-end last-import-token)))
> (if (and start end)
> (let (sort-fold-case)
> (sort-lines reverse start end)
> (goto-char start)))))))
>
>
>(defun jde-wiz-strip-package-from-class (class-name)
> "Strips the package name from fully qualified java class"
> (let (i return-name)
> (setq return-name class-name)
> (setq i (string-match "[^.]*$" class-name))
> (if i
> (setq return-name (substring class-name i)))
> return-name))
>
>
>(defun jde-wiz-get-existing-import (class-name)
> ""
> (let ((import-re "import[ ]+\\(.*\\)[ ]*;")
> (imports nil)
> (existing-import)
> (result nil))
> (save-excursion
> (goto-char (point-max))
> (while (re-search-backward import-re (point-min) t)
> (looking-at import-re)
> (setq existing-import (buffer-substring-no-properties
> (match-beginning 1)
> (match-end 1)))
> (if (string-equal class-name
> (jde-wiz-strip-package-from-class
> existing-import))
> (setq result existing-import))))
> result))
>
>;; Thanks to Jim LoVerde<[EMAIL PROTECTED]> for providing the code to
>;; prevent duplicate imports.
>(defun jde-wiz-find-and-import (class)
> "*Insert an import statement for a class in the current buffer.
>CLASS is an unqualified class name. This function inserts an import
>statement only if one does not already exist for the class. This
>function searches the classpath for a class (or classes) that match
>CLASS. If it finds only one, it inserts an import statements for the
>class at the head of the current buffer. If it finds more than one
>class that matches CLASS, it prompts you to select which class to
>import. You can use the variable
>`jde-wiz-insert-excluded-packages-regexp' to prevent specified classes
>from being imported or consider for import. This command uses the
>JDE's BeanShell interpreter. It starts the interpreter if it is not
>already running so there may be a short delay generating the first
>import statement in the session. Note that you must explicitly include
>any directories or jars that you want the command to search in your
>classpath, including jars implicitly included by the jvm, e.g.,
>rt.jar."
> (interactive
> (list (read-from-minibuffer "Class: "
> (thing-at-point 'symbol))))
> (let (existing-import)
> (setq existing-import (jde-wiz-get-existing-import class))
> (if (not (null existing-import))
> (message "Skipping: already imported %s" existing-import)
> (let ((imports
> (bsh-eval-r
> (concat "jde.util.JdeUtilities.getQualifiedName(\""
> class "\");"))))
> (if imports
> (jde-wiz-insert-imports imports)
> (message "Error: could not find %s." class))))))
>
>
>(defun jde-wiz-insert-imports (new-imports)
> (let* ((imports
> (mapcar 'jde-wiz-strip-excluded-imports
> (jde-wiz-strip-existing-imports new-imports
> (jde-wiz-get-imports)))))
> ;;Delete the nil which result from the excluded ones
> (setq imports (delq nil imports))
> ;; If more than one class matches the specified class name,
> ;; prompt the user to select a class for import.
> (if (> (length imports) 1 )
> (jde-wiz-choose-imports imports)
> (jde-wiz-insert-imports-into-buffer imports))))
>
>
>;;; begin JVL commented out (replaced below)
>;;;(defun jde-wiz-strip-excluded-imports (new-import)
>;;; "Removes excluded imports from the list"
>;;; ;;if the string matchs the regexp we want to ignore it.
>;;; (if (string-match jde-wiz-insert-excluded-packages-regexp
>;;; (concat " " new-import))
>;;; (progn (message "Excluding import: %s" new-import)
>;;; ())
>;;; new-import))
>;;; end JVL commented out
>
>;;; begin JVL change to support a list of regexps
>(defun jde-wiz-strip-excluded-imports (new-import)
> "Removes excluded imports from the list"
> ;;if the string matchs the regexp we want to ignore it.
> (let ((temp-list (nconc (list jde-wiz-insert-excluded-packages-regexp)
> jde-wiz-insert-excluded-packages-regexp-list)))
> (if temp-list
> (let (i n result)
> (setq i 0)
> (setq n (length temp-list))
> (setq result new-import)
> (while (< i n)
> (let ((exclude-regexp
> (nth i temp-list)))
> (if (string-match exclude-regexp new-import)
> (progn
> (message "Excluding import: %s" new-import)
> (setq result nil)))
> (setq i (+ i 1))))
> result)
> new-import)))
>
>(defun jde-wiz-strip-excluded-import (exclude-regexp new-import)
> "Removes excluded imports from the list"
> ;;if the string matchs the regexp we want to ignore it.
> (if (string-match exclude-regexp (concat " " new-import))
> (progn (message "Excluding import: %s" new-import)
> ())
> new-import))
>;;; end JVL change to support a list of regexps
>
>
>(defun jde-wiz-insert-imports-into-buffer (new-imports)
> "Inserts imports into the correct place in the buffer."
> (let (i n)
> (save-excursion
> (goto-char (jde-wiz-get-import-insertion-point))
> (setq i 0)
> (setq n (length new-imports))
> (while (< i n)
> (let ((new-import
> (nth i new-imports)))
> (progn
> (insert
> (concat "import " new-import ";\n"))
> (message "Imported %s" new-import))
> (setq i (+ i 1)))))))
>
>
>(defun jde-wiz-strip-existing-imports (new-imports existing-imports)
> "Exclude classes that have already been imported."
> (let (i n return-imports)
> (setq i 0)
> (setq n (length new-imports))
> (while (< i n)
> ;;iterate through the new imports
> (let((new-import
> (nth i new-imports)))
> ;;Strip out those alreay there
> (when (not (find new-import existing-imports :test 'string=))
> (setq return-imports (nconc (list new-import)
> return-imports))))
> (setq i(+ i 1)))
> ;;Return any that still exist
> return-imports))
>
>
>(defun jde-wiz-choose-imports (new-imports)
> "Prompts the user to select a class to import from a list of similarly
> named candidates."
> (let ((buf (get-buffer-create "*Select Import Class*" )))
> (setq jde-wiz-import-window-config (current-window-configuration))
> (setq jde-wiz-selected-import (car new-imports))
> (set-buffer buf)
> (widget-insert "Several classes match the name you specified.\n")
> (widget-insert "Select the one you want to import.\n")
> (widget-insert "Then click the OK button.\n" )
> (let ((args (list
> 'radio-button-choice
> :value (car new-imports)
> :notify (lambda (widget &rest ignore)
> (setq jde-wiz-selected-import (widget-value widget))
> (message "You selected: %s"
> (widget-value widget))))))
> (setq args (nconc
> args
> (mapcar (lambda (x) (list 'item x)) new-imports)))
> (apply 'widget-create args))
> (widget-insert "\n")
> (widget-create 'push-button
> :notify (lambda (&rest ignore)
> (let ((dialog-buffer
> (current-buffer)))
>;; begin JVL Corrected to work if you have (setq pop-up-windows nil)
> (if pop-up-windows (delete-window))
>;; end JVL Corrected to work if you have (setq pop-up-windows nil)
> (kill-buffer dialog-buffer)
> (set-window-configuration jde-wiz-import-window-config)
> (jde-wiz-insert-imports-into-buffer (cons
jde-wiz-selected-import nil))
> (message "Import complete.")))
> "Ok")
> (use-local-map widget-keymap)
> (widget-setup)
> (pop-to-buffer buf)))
>
>;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>;; Method Interface Implementation wizard ;;
>;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>
>(defun jde-wiz-get-unqualified-name (name)
> (string-match "[^.]+$" name)
> (substring name (match-beginning 0) (match-end 0)))
>
>
>(defun jde-wiz-update-implements-clause (interface-name)
> (interactive
> "sEnter interface: ")
> (let ((interface
> (jde-wiz-get-unqualified-name interface-name)))
> (save-excursion
> (let* ((class-re "class[ \t]+\\([a-zA-z]+[a-zA-Z0-9._]*\\).*[ \n]*")
> (open-brace-pos
> (scan-lists (point) -1 1))
> (class-name-end-pos
> (when open-brace-pos
> (goto-char open-brace-pos)
> (when (re-search-backward class-re (point-min) t)
> (looking-at class-re)
> (match-end 1))))
> (implements-keyword-end-pos
> (when (and open-brace-pos class-name-end-pos)
> (goto-char open-brace-pos)
> (if (re-search-backward "implements" class-name-end-pos t)
> (match-end 0)))))
> (if implements-keyword-end-pos
> (progn
> (goto-char implements-keyword-end-pos)
> (insert (concat " " interface ", ")))
> (when class-name-end-pos
> (goto-char (- open-brace-pos 1))
> (insert (concat " implements " interface " "))))))))
>
>
>(defun jde-wiz-implement-interface (interface-name)
> "*Generate a skeleton implementation of a specified interface."
> (interactive
> "sInterface name: ")
> (condition-case err
> (let* ((nl-brace-p
> (find 'before
> (cdr (assoc 'defun-open c-hanging-braces-alist))))
> (code
> (bsh-eval-r
> (concat
> "jde.wizards.InterfaceFactory.makeInterface(\""
> interface-name "\", true, true, "
> (if nl-brace-p "true" "false") ");"))))
> (if code
> (let ((required-imports
> (bsh-eval-r
> "jde.wizards.InterfaceFactory.getImportedClasses();")))
> (insert code)
> (if required-imports
> (jde-wiz-insert-imports-into-buffer required-imports))
> (jde-wiz-update-implements-clause interface-name))))
> (error
> (message "%s" (error-message-string err)))))
>
>
>;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>;; Method override wizard ;;
>;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>
>
>(defun jde-wiz-get-method-class ()
> (let ((class-re "class[ \t]+\\([a-zA-z]+[a-zA-Z0-9._]*\\).*[ \n]*"))
> (save-excursion
> (let ((open-brace-pos
> (scan-lists (point) -1 1)))
> (when open-brace-pos
> (goto-char open-brace-pos)
> (when (re-search-backward class-re (point-min) t)
> (looking-at class-re)
> (buffer-substring-no-properties
> (match-beginning 1)
> (match-end 1))))))))
>
>
>(defun jde-wiz-override-method (method-name)
> "Overrides a method whose name you specify.
>This command creates a skeleton implementation of the
>overridden method at point. This command infers the
>qualified name of the class of the overriden method by
>prepending the package name of the current buffer to
>the class containing point. If the class defines
>more than one method of the same name, this command
>prompts you to select the desired method from a list
>of method prototypes.
>
>This command also generates import statements for
>the parameter and return types of the overridden method.
>The import statements are inserted after the last
>existing import statement or the package statement
>or the first blank line in the source file. Import
>statements are generated only for types for which an
>import statement does not already exist in the file.
>
>NOTE: this command works only if the overriding class
> has been previously compiled."
> (interactive
> "sMethod name: ")
> (condition-case err
> (let* ((package-name (jde-wiz-get-package-name))
> (class-name (jde-wiz-get-method-class))
> (qualified-class-name
> (if (and package-name class-name)
> (concat package-name "." class-name)
> class-name)))
> (if qualified-class-name
> (let ((signatures
> (bsh-eval
> (concat
> "jde.wizards.MethodOverrideFactory.getCandidateSignatures(\""
> qualified-class-name "\",\"" method-name "\");") t)))
> (if signatures
> (if (> (length signatures) 1)
> (jde-wiz-override-variant-method signatures)
> (jde-wiz-override-method-internal (car signatures) signatures))))))
> (error
> (message "%s" (error-message-string err)))))
>
>(defun jde-wiz-override-method-internal (selected-method methods)
> (let* ((variant
> (position selected-method methods :test 'string=))
> (nl-brace-p
> (find 'before
> (cdr (assoc 'defun-open c-hanging-braces-alist))))
> (skeleton
> (bsh-eval-r
> (concat
> "jde.wizards.MethodOverrideFactory.getMethodSkeleton("
> (int-to-string variant)
> (if nl-brace-p
> ", true"
> ", false")
> ");")))
> (required-imports
> (bsh-eval-r
> "jde.wizards.MethodOverrideFactory.getImportedClasses();")))
> (insert skeleton)
> (if required-imports
> (jde-wiz-insert-imports required-imports))))
>
>
>(defun jde-wiz-override-variant-method (methods)
> (let ((buf (get-buffer-create "*Choose Method*")))
> (setq jde-wiz-source-buffer (current-buffer))
> (setq jde-wiz-method-variants methods)
> (setq jde-wiz-selected-method (car methods))
> (set-buffer buf)
> (widget-insert "Select the method you want to override.\n")
> (widget-insert "Then click the Ok button.\n\n")
> (let ((args (list
> 'radio-button-choice
> :value (car methods)
> :notify (lambda (widget &rest ignore)
> (setq jde-wiz-selected-method (widget-value widget))
> (message "You selected: %s"
> (widget-value widget))))))
> (setq args (nconc
> args
> (mapcar (lambda (x) (list 'item x)) methods)))
> (apply 'widget-create args)
> )
> (widget-insert "\n")
> (widget-create 'push-button
> :notify (lambda (&rest ignore)
> (let ((dialog-buffer
> (current-buffer)))
> (set-buffer jde-wiz-source-buffer)
> (delete-window)
> (kill-buffer dialog-buffer)
> (jde-wiz-override-method-internal
> jde-wiz-selected-method
> jde-wiz-method-variants)
> (message "Method inserted.")
> ))
> "Ok")
> (use-local-map widget-keymap)
> (widget-setup)
> (pop-to-buffer buf)))
>
>
>;;
>;; Contributed by Rohit Namjoshi <[EMAIL PROTECTED]>
>;;
>(defun jde-browse-class ()
> "Displays class at point in BeanShell class browser."
> (interactive)
> (condition-case err
> (let* ((unqualified-name (thing-at-point 'symbol))
> (class-names
> ;;expand the names into full names, or a list of names
> (bsh-eval-r
> (concat "jde.util.JdeUtilities.getQualifiedName(\""
> unqualified-name "\");")))
> ;; Pick first match
> (cmd (concat "browseClass(\"" (car class-names) "\");")))
> (if (eq nil class-names)
> (error "Cannot find %s" unqualified-name))
> (message cmd)
> (bsh-eval cmd))
> (error
> (message "%s" (error-message-string err)))))
>
>(provide 'jde-wiz)
>
>;; $Log: jde-wiz.el,v $
>;; Revision 1.23 2000/06/22 02:50:25 paulk
>;; The import wizard dialog now uses radio buttons rather than check boxes
to select
>;; the class to import. Thanks to Mark Gibson for this enhancement.
>;;
>;; Revision 1.22 2000/06/01 06:01:14 paulk
>;; Added jde-sort-imports command. Thanks to David Ponce
<[EMAIL PROTECTED]>.
>;;
>;; Revision 1.21 2000/01/18 07:11:26 paulk
>;; Added jde-show-class-source. Thanks to Phil Lord for the initial
>;; implementation of this command.
>;;
>;; Revision 1.20 1999/12/19 07:02:30 paulk
>;; Changed import wizard to use jde.util.JdeUtilities.getQualifiedName
>;; eliminated redundancy. Thanks to Len Trigg <[EMAIL PROTECTED]>
>;; for this improvement.
>;;
>;; Revision 1.19 1999/11/01 03:11:42 paulk
>;; Added jde-browse-class contributed by Rohit Namjoshi
<[EMAIL PROTECTED]>.
>;;
>;; Revision 1.18 1999/10/17 04:35:05 paulk
>;; Fixed a line in jde-wiz.el, where an int is concat'd with some
>;; strings. This is not allowed by XEmacs 21.1.
>;;
>;; Revision 1.17 1999/10/01 05:58:14 paulk
>;; Added jde-wiz-update-class-list function contributed by Phillip Lord.
>;;
>;; Revision 1.16 1999/09/17 06:52:50 paulk
>;; Fixed regression error where the interface wizard was putting quotes
>;; around the code inserted into the source buffer.
>;;
>;; Revision 1.15 1999/08/29 04:29:18 paulk
>;; Patches provided by Michael Ernst <[EMAIL PROTECTED]>
>;;
>;; Revision 1.14 1999/08/23 02:13:43 paulk
>;; Fixed regression bug in jde-wiz-implement-interface caused by recent
>;; change in jde-wiz-insert-imports.
>;;
>;; Revision 1.13 1999/06/22 21:12:20 paulk
>;; Added variable to filter out unwanted classes from the list of classes
being
>;; considered for import command by jde-find-and-import. The
jde-find-and-import
>;; command now prompts the user if more than one class matches the specified
>;; import name. Thanks to Phillip Lord <[EMAIL PROTECTED]> for these
enhancements.
>;;
>;; Revision 1.12 1999/05/07 20:42:25 paulk
>;; Cosmetic change.
>;;
>;; Revision 1.11 1999/05/07 20:40:49 paulk
>;; Added new command, jde-wiz-find-and-import, that, given an unqualified
class
>;; name, generates and inserts an import statement for that class.
>;;
>;; Revision 1.10 1999/02/17 19:16:07 paulk
>;; Provided more robust error handling for the interface wizard. The wizard
>;; no longer kills the bsh when it cannot create an interface and provides
>;; meaningfull error messages.
>;;
>;; Revision 1.9 1999/02/15 01:12:54 paulk
>;; Fixed bug in jde-wiz-get-method-class that caused it to fail when the
open bracket
>;; for the class was not on the same line as the class keyworkd. Thanks to
>;; [EMAIL PROTECTED] (Phillip Lord) for diagnosing this bug.
>;;
>;; Revision 1.8 1999/02/12 15:13:00 paulk
>;; Added jde-wiz-import function.
>;;
>;; Revision 1.7 1999/02/11 19:14:50 paulk
>;; Fixed bug in jde-wiz-update-implements-clause.
>;;
>;; Revision 1.6 1999/02/11 18:28:40 paulk
>;; Corrected missing parentheses.
>;;
>;; Revision 1.5 1998/11/22 22:03:43 paulk
>;; Fixed bug in interface wizard.
>;;
>;; Revision 1.4 1998/11/22 21:55:33 paulk
>;; Fixed bug in interface wizard.
>;;
>;; Revision 1.3 1998/11/21 02:41:34 paulk
>;; Fixed bug.
>;; Added implements clause update function to interface implementation
wizard.
>;;
>;; Revision 1.2 1998/11/10 00:46:39 paulk
>;; Added smart import insertion to interface wizard.
>;;
>;; Revision 1.1 1998/11/08 00:39:24 paulk
>;; Initial revision
>;;
>
>
>;; End of jde-wiz.el
>
>
>--
>****************************************************
>Jim LoVerde, Technical Architect
>Strategic Technology Resources
>http://www.str.com
>voice 312.674.4798 fax 312.697.3801
>mobile 773.398.9539 pager [EMAIL PROTECTED]
>
>
>
>Attachment Converted: "g:\eudora\attach\smime21.p7s"
>
