dominik  committed 071fb6c


  • Participants
  • Parent commits 0583df3

Comments (0)

Files changed (8)

-This is the CHANGES file of the IDLWAVE distribution, version 3.15 
+This is the CHANGES file of the IDLWAVE distribution, version VERSIONTAG 
 The file covers only the changes for Revision 3.0 and later.  Earlier
 changes are documented in the (obsolete) files idl.el and
 idl-shell.el, available at
+Revision 4.4
+   - IDLWAVE understands inheritance in all important contexts.
+   - Completion of system variables and their tags.
+   - Completion of class structure tags on "self" variables.
+Revision 4.3
+   - The IDL procedure "BEEP" works in the IDLWAVE Shell
+   - Fixed bug with dedicated shell frame display under Emacs
+     (patch from Stein Vidar Hagfors Haugan <>)
+Revision 4.2
+   - Fixed bug with context-help when at end-of-buffer.
+   - Ambiguous kwd abbrev and non-existent in online help kwd
+     now ring the bell.
+   - Toggling the toolbar causes a redraw-frame on Emacs (21 only).
+   - Allow for space between a function and `('.
+   - Forcing completion type with prefix arg to M-TAB fixed in the shell.
+   - Fixed bug when exiting shell with *idl* as the only window.
+   - The class of object "self" is assumed of be the current routines class.
+Revision 4.1
+   - Fixed bug in which unresolved routines could shadow catalog entries.
+   - Fixed the incorrect installation instructions in README.hlp.
+   - Online help for non-system stuff makes use of the DocLib file header.
+   - Abbreviated keywords are treated correctly for online help.
+   - Source files displayed as online help can be fontified
+     (off by default, see variable `idlwave-help-fontify-source-code').
+   - Multiple definitions of a routine in one file count as shadowing.
+   - Facility to send single characters to interact with GET_KBRD (see manual)
+   - The shell defines a system variable !IDLWAVE_VERSION, which can
+     be used by a program to detect if it is running under Emacs or not.
+   - More efficient way of querying the shell for routine info.
+   - Fixed bug in get_rinfo -> 10 mode keywords recognized.
+   - Fixed bug with translation of help topics.
+   - Fixed bug for completion context after continuation lines.
+   - Fixed bug with Keyword insertion after `(' from Routine Info Window.
+Revision 4.0
+   - Fast and accurate IDL online help.  Two additional files need to
+     be installed, they are not part of the standard distribution.
+     Help is triggered with `M-?', and by clicking with mouse-3 on
+     items in the Routine Info buffer or in *Completions*.
+   - Global IDL namespace analysis to produce a list of routines
+     with definitions in several files.
+   - Clicking on a keyword in the routine-info buffer inserts
+     the keyword in the buffer from which `C-c ?' was called.
+   - More intelligent completion in OBJ_NEW calls.
+   - Class completion after PRO and FUNCTION.
+   - Abbrev expansion in the shell.
+   - `idlwave-pad-keywords' can also have a value `keep'.
+   - `idlwave-scan-all-buffers-for-routine-info' can also have value
+     `current' to scan only the current buffer but no other buffers. 
 Revision 3.15
+2000-10-03  Carsten Dominik  <>
+	* idlwave 4.4.
 2000-08-30  Steve Youngs  <>
 	* idlwave.texi: Backout patch to replace '@ifnottex'
 # Boston, MA 02111-1307, USA.
 VERSION = 1.21
 MAINTAINER = Carsten Dominik <>
 PACKAGE = idlwave
 PKG_TYPE = regular

File idlw-rinfo.el

 ;; Copyright (c) 1999, 2000 Free Software Foundation
 ;; Author: Carsten Dominik <>
-;; Version: 4.2
+;; Version: VERSIONTAG
 ;; Keywords: languages
 ;; This file is part of GNU Emacs.
 ;; and procedures.  This information is extracted automatically from
 ;; the IDL documentation.
-;; Created by get_rinfo on Tue Jun 20 11:30:48 2000
+;; Created by get_rinfo on Tue Oct  3 13:04:10 2000
 ;; IDL version: 5.3
 ;; Number of files scanned:  6
 ;;       903 syntax entries in file refguide.txt
 ;;         0 syntax entries in file insight.txt
 ;;        43 syntax entries in file obsolete.txt
 ;; Number of routines found: 1251
-;; Number of keywords found: 5287
+;; Number of keywords found: 5288
     ("INT_3D"                 fun nil                 (system) "Result = %s( Fxyz, AB_Limits, PQ_Limits, UV_Limits, Pts)" (("DOUBLE")))
     ("INT_TABULATED"          fun nil                 (system) "Result = %s( X, F)" (("SORT")))
     ("INTARR"                 fun nil                 (system) "Result = %s( D1, ..., D8)" (("NOZERO")))
-    ("INTERPOL"               fun nil                 (system) "Result = %s( V, N) or Result = INTERPOL( V, X, U)" (("QUADRATIC") ("SPLINE")))
+    ("INTERPOL"               fun nil                 (system) "Result = %s( V, N) or Result = INTERPOL( V, X, U)" (("LSQUADRATIC") ("QUADRATIC") ("SPLINE")))
     ("INTERPOLATE"            fun nil                 (system) "Result = %s( P, X [, Y [, Z]])" (("CUBIC") ("GRID") ("MISSING")))
     ("INVERT"                 fun nil                 (system) "Result = %s( Array [, Status])" (("DOUBLE")))
     ("IOCTL"                  fun nil                 (system) "Result = %s( File_Unit [, Request, Arg])" (("BY_VALUE") ("MT_OFFLINE") ("MT_REWIND") ("MT_SKIP_FILE") ("MT_SKIP_RECORD") ("MT_WEOF") ("SUPRESS_ERROR")))
     ("Init"                   fun "TrackBall"         (system) "Result = Obj -> [%s::]%s( Center, Radius)" (("AXIS") ("CONSTRAIN") ("MOUSE")))
     ("Update"                 fun "TrackBall"         (system) "Result = Obj -> [%s::]%s( sEvent)" (("MOUSE") ("TRANSFORM") ("TRANSLATE")))
-  "1251 builtin routines with 5287 keywords for IDL version 5.3.")
+  "1251 builtin routines with 5288 keywords for IDL version 5.3.")
+(setq idlwave-system-variables-alist
+  '(
+    ("C")
+    ("D" ("NAME") ("X_SIZE") ("Y_SIZE") ("X_VSIZE") ("Y_VSIZE") ("X_CH_SIZE") ("Y_CH_SIZE") ("X_PX_CM") ("Y_PX_CM") ("N_COLORS") ("TABLE_SIZE") ("FILL_DIST") ("WINDOW") ("UNIT") ("FLAGS") ("ORIGIN") ("ZOOM"))
+    ("DIR")
+    ("DLM_PATH")
+    ("DPI")
+    ("DTOR")
+    ("EDIT_INPUT")
+    ("ERROR_STATE" ("NAME") ("BLOCK") ("CODE") ("SYS_CODE") ("MSG") ("SYS_MSG") ("MSG_PREFIX"))
+    ("EXCEPT")
+    ("HELP_PATH")
+    ("JOURNAL")
+    ("MAP" ("PROJECTION") ("SIMPLE") ("FILL_METHOD") ("UP_FLAGS") ("UP_NAME") ("P0LON") ("P0LAT") ("U0") ("V0") ("SINO") ("COSO") ("ROTATION") ("SINR") ("COSR") ("UV") ("POLE") ("UV_BOX") ("LL_BOX") ("SEGMENT_LENGTH") ("P") ("PIPELINE"))
+    ("MORE")
+    ("MOUSE" ("X") ("Y") ("BUTTON") ("TIME"))
+    ("ORDER")
+    ("PATH")
+    ("PI")
+    ("PROMPT")
+    ("QUIET")
+    ("RADEG")
+    ("VALUES" ("F_INFINITY") ("F_NAN") ("D_INFINITY") ("D_NAN"))
+(setq idlwave-system-class-info
+  '(
+    ("IDLgrLegend"
+     (inherits "IDLgrModel"))
+    ("IDLgrAxis"
+     (inherits))
+    ("IDLgrContour"
+     (inherits))
+    ("IDLgrROI"
+     (inherits "IDLanROI"))
+    ("IDLgrSurface"
+     (inherits))
+    ("IDLgrWindow"
+     (inherits))
+    ("IDLgrVolume"
+     (inherits))
+    ("IDLgrPolygon"
+     (inherits))
+    ("IDLgrROIGroup"
+     (inherits "IDLanROIGroup"))
+    ("IDLgrPlot"
+     (inherits))
+    ("IDLgrText"
+     (inherits))
+    ("IDLgrColorbar"
+     (inherits "IDLgrModel"))
+    ("IDLgrImage"
+     (inherits))
+    ("IDLgrView"
+     (inherits "IDL_Container"))
+    ("IDLgrPolyline"
+     (inherits))
+    ("IDLgrLight"
+     (inherits))
+    ("IDLgrClipboard"
+     (inherits))
+    ("IDLgrPrinter"
+     (inherits))
+    ("IDLgrVRML"
+     (inherits))
+    ("IDLgrBuffer"
+     (inherits))
+    ("IDLgrModel"
+     (inherits "IDL_Container"))
+    ("IDLgrScene"
+     (inherits "IDL_Container"))
+    ("IDLgrViewgroup"
+     (inherits "IDL_Container"))
+    ("IDLgrMPEG"
+     (inherits))
+    ("IDLdbRecordset"
+     (inherits))
+    ("IDLdbDatabase"
+     (inherits))
+    ("IDLanROI"
+     (inherits))
+    ("IDLanROIGroup"
+     (inherits "IDL_Container"))
+    ("IDLgrPalette"
+     (inherits))
+    ("IDLgrFont"
+     (inherits))
+    ("IDLgrPattern"
+     (inherits))
+    ("IDLgrSymbol"
+     (inherits))
+    ("IDLffDICOM"
+     (inherits))
+    ("IDLffDXF"
+     (inherits))
+    ("TrackBall"
+     (inherits))
+    ("IDL_Container"
+     (inherits))
+    ("IDLgrTessellator"
+     (inherits))))
 (provide 'idlw-rinfo)
 (provide 'idlwave-rinfo)

File idlw-shell.el

 ;; Author: Chris Chase <>
 ;; Maintainer: Carsten Dominik <>
-;; Version: 4.2
+;; Version: VERSIONTAG
 ;; Date: $Date$
 ;; Keywords: processes
   :group 'idlwave-shell-general-setup
   :type 'boolean)
-(defcustom idlwave-shell-file-name-chars "~/A-Za-z0-9+@:_.$#%={}-"
+(defcustom idlwave-shell-file-name-chars "-~/A-Za-z0-9+@:_.$#%={}"
   "The characters allowed in file names, as a string.
 Used for file name completion. Must not contain `'', `,' and `\"'
 because these are used as separators by IDL."
       (if (and idlwave-shell-ready
                ;; Check for IDL prompt
-                 (beginning-of-line)
+		 (forward-line 0)
+                 ;; (beginning-of-line) ; Changed for Emacs 21
                  (looking-at idlwave-shell-prompt-pattern)))
           ;; IDL ready for command
           (if idlwave-shell-pending-commands
 	   ;; Interpret input as a character - ignore non-char input
 	   (condition-case nil
 	       (setq c (read-char))
-	     (error (setq c nil)))
+	     (error (ding) (throw 'exit "Character mode off")))
 	    ((null c)               ; Non-char event: ignore
       (delete-frame idlwave-shell-idl-wframe)
       (setq idlwave-shell-idl-wframe nil
 	    idlwave-shell-display-wframe nil))
-    (when (and (window-live-p win)
-	       (not (one-window-p)))
+    (when (window-live-p win)
       (delete-window win))

File idlw-toolbar.el

 ;; Copyright (c) 1999, 2000 Free Software Foundation
 ;; Author: Carsten Dominik <>
-;; Version: 4.2
+;; Version: VERSIONTAG
 ;; Date: $Date$
 ;; Keywords: processes
 ;; Author: Chris Chase <>
 ;; Maintainer: Carsten Dominik <>
-;; Version: 4.2
+;; Version: VERSIONTAG
 ;; Date: $Date$
 ;; Keywords: languages
   "Face for highlighting links into IDLWAVE online help."
   :group 'idlwave-online-help)
+(defcustom idlwave-help-activate-links-agressively t
+  "*Non-nil means, make all possible links in help active.
+This just activates all words which are also a help topic - some links may
+be misleading."
+  :group 'idlwave-online-help
+  :type 'boolean)
 (defgroup idlwave-completion nil
   "Completion options for IDLWAVE mode."
   :prefix "idlwave"
   :group 'idlwave-completion
   :type 'boolean)
+(defcustom idlwave-support-inheritance t
+  "Non-nil means, treat inheritance with completion, online help etc.
+When nil,  IDLWAVE only knows about the native methods and tags of a class,
+not about inherited ones."
+  :group 'idlwave-routine-info
+  :type 'boolean)
 (defcustom idlwave-completion-show-classes 1
   "*Number of classes to show when completing object methods and keywords.
 When completing methods or keywords for an object with unknown class,
   "Character which is inserted as a last character on previous line by
    \\[idlwave-split-line] to begin a continuation line.  Normally $.")
-(defconst idlwave-mode-version " 4.2")
+(defconst idlwave-mode-version " VERSIONTAG")
 (defmacro idlwave-keyword-abbrev (&rest args)
   "Creates a function for abbrev hooks to call `idlwave-check-abbrev' with args."
       (setq res (cons new res)))
     (nreverse res)))
+;; Creating new sintern tables
+(defun idlwave-new-sintern-type (tag)
+  "Define a variable and a function to sintern the new type TAG.
+This defines the function `idlwave-sintern-TAG' and the variable
+  (let* ((name (symbol-name tag))
+	 (names (concat name "s"))
+	 (var (intern (concat "idlwave-sint-" names)))
+	 (func (intern (concat "idlwave-sintern-" name))))
+    (set var nil) ; initial value of the association list
+    (fset func    ; set the function
+	  `(lambda (name &optional set)
+	     (cond ((not (stringp name)) name)
+		   ((cdr (assoc (downcase name) ,var)))
+		   (set
+		    (setq ,var (cons (cons (downcase name) name) ,var))
+		    name)
+		   (name))))))
+(defun idlwave-reset-sintern-type (tag)
+  "Reset the sintern variable associated with TAG."
+  (set (intern (concat "idlwave-sint-" (symbol-name tag) "s")) nil))
 	;; return the current value
+(defvar idlwave-update-rinfo-hook nil
+  "List of functions which should run after a global rinfo update.
+Does not run after automatic updates of buffer or the shell.")
 (defun idlwave-update-routine-info (&optional arg)
   "Update the internal routine-info lists.
 These lists are used by `idlwave-routine-info' (\\[idlwave-routine-info])
 	    ;;    causes the concatenation *delayed*, so not in time for
 	    ;;    the current command.  Therefore, we do a concatenation
 	    ;;    now, even though the shell might do it again.
-	    (idlwave-concatenate-rinfo-lists))
+	    (idlwave-concatenate-rinfo-lists nil t))
 	(when ask-shell
 	  ;; Ask the shell about the routines it knows.
 	  (message "Querying the shell")
-	  (idlwave-shell-update-routine-info))))))
+	  (idlwave-shell-update-routine-info nil t))))))
 (defun idlwave-load-system-rinfo ()
   ;; Load and case-treat the system and lib info files.
 	  (setq idlwave-library-routines (idlwave-sintern-rinfo-list
 					  idlwave-library-routines 'sys))
 	  (message "Normalizing idlwave-library-routines...done"))
-      (error nil))))
+      (error nil)))
+  (run-hooks 'idlwave-after-load-rinfo-hook))
 (defun idlwave-update-buffer-routine-info ()
   (let (res)
     (setq idlwave-buffer-routines 
 	  (idlwave-sintern-rinfo-list res t))))
-(defun idlwave-concatenate-rinfo-lists (&optional quiet)
+(defun idlwave-concatenate-rinfo-lists (&optional quiet run-hook)
   "Put the different sources for routine information together."
   ;; The sequence here is important because earlier definitions shadow 
   ;; later ones.  We assume that if things in the buffers are newer
      (length idlwave-buffer-routines)
      (length idlwave-compiled-routines)
      (length idlwave-library-routines)
-     (length idlwave-system-routines))))
+     (length idlwave-system-routines)))
+  (if run-hook
+      (run-hooks 'idlwave-update-rinfo-hook)))
 (defun idlwave-class-alist ()
   "Return the class alist - make it if necessary."
       (while (setq buf (pop buffers))
 	(set-buffer buf)
-	(if (eq major-mode 'idlwave-mode)
+	(if (and (eq major-mode 'idlwave-mode)
+		 buffer-file-name)
 	    ;; yes, this buffer has the right mode.
 	    (progn (setq res (condition-case nil
 ;; defined routines. 
 pro idlwave_print_info_entry,name,func=func,separator=sep
   ;; See if it's an object method
   if name eq '' then return
+pro idlwave_get_sysvars
+  catch,error_status
+  if error_status ne 0 then begin
+      print, 'Cannot get info about system variables'
+  endif else begin
+      help,/brief,output=s,/system_variables  ; ? unsafe use of OUTPUT=
+      s = strtrim(strjoin(s,' ',/single),2)   ; make one line
+      v = strsplit(s,' +',/regex,/extract)    ; get variables
+      for i=0,n_elements(v)-1 do begin
+          t = ['']                            ; get tag list
+          a=execute('if n_tags('+v[i]+') gt 0 then t=tag_names('+v[i]+')')
+          print, 'IDLWAVE-SYSVAR: '+v[i]+' '+strjoin(t,' ',/single)
+      endfor
+  endelse
+pro idlwave_get_class_tags, class
+  res = execute('tags=tag_names({'+class+'})')
+  if res then print,'IDLWAVE-CLASS-TAGS: '+class+string(format='(1000(\" \",A))',tags)
-  "The idl program to get the routine info stuff.
-The output of this program is parsed by `idlwave-shell-routine-info-filter'.")
+  "The idl programs to get info from the shell.")
 (defvar idlwave-idlwave_routine_info-compiled nil
   "Remembers if the routine info procedure is already compiled.")
 (defvar idlwave-shell-temp-pro-file)
 (defvar idlwave-shell-temp-rinfo-save-file)
-(defun idlwave-shell-update-routine-info (&optional quiet)
+(defun idlwave-shell-update-routine-info (&optional quiet run-hooks)
   "Query the shell for routine_info of compiled modules and update the lists."
   ;; Save and compile the procedure.  The compiled procedure is then
   ;; saved into an IDL SAVE file, to allow for fast RESTORE.
-      (idlwave-concatenate-rinfo-lists ,quiet))
+      (idlwave-concatenate-rinfo-lists ,quiet ,run-hooks))
 ;; ---------------------------------------------------------------------------
 (defvar idlwave-completion-help-info nil)
 (defvar idlwave-current-obj_new-class nil)
+(defvar idlwave-complete-special nil)
 (defun idlwave-complete (&optional arg module class)
   "Complete a function, procedure or keyword name at point.
       (setq this-command last-command)
+     ;; Check for any special completion functions
+     ((and idlwave-complete-special
+	   (idlwave-complete-special)))
      ((null what)
       (error "Nothing to complete here"))
      ((eq what 'procedure)
       ;; Complete a procedure name
       (let* ((class-selector (idlwave-determine-class (nth 3 where-list) 'pro))
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (isa (concat "procedure" (if class-selector "-method" "")))
 	     (type-selector 'pro))
 	(setq idlwave-completion-help-info 
-	      (list 'routine nil type-selector class-selector))
+	      (list 'routine nil type-selector class-selector nil super-classes))
 	 'procedure (if class-selector 'method 'routine)
 	 (idlwave-routines) 'idlwave-selector
      ((eq what 'function)
       ;; Complete a function name
       (let* ((class-selector (idlwave-determine-class (nth 3 where-list) 'fun))
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (isa (concat "function" (if class-selector "-method" "")))
 	     (type-selector 'fun))
 	(setq idlwave-completion-help-info 
-	      (list 'routine nil type-selector class-selector))
+	      (list 'routine nil type-selector class-selector nil super-classes))
 	 'function (if class-selector 'method 'routine)
 	 (idlwave-routines) 'idlwave-selector
 	     (type-selector 'pro)
 	     (class (idlwave-determine-class where 'pro))
 	     (class-selector class)
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (isa (format "procedure%s-keyword" (if class "-method" "")))
 	     (entry (idlwave-best-rinfo-assq
 		     name 'pro class (idlwave-routines)))
 	(unless list (error (format "No keywords available for procedure %s"
 				    (idlwave-make-full-name class name))))
 	(setq idlwave-completion-help-info 
-	      (list 'keyword name type-selector class-selector))
+	      (list 'keyword name type-selector class-selector nil super-classes))
 	 'keyword 'keyword list nil
 	 (format "Select keyword for procedure %s%s"
 	     (type-selector 'fun)
 	     (class (idlwave-determine-class where 'fun))
 	     (class-selector class)
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (isa (format "function%s-keyword" (if class "-method" "")))
 	     (entry (idlwave-best-rinfo-assq
 		     name 'fun class (idlwave-routines)))
 	(unless list (error (format "No keywords available for function %s"
 	(setq idlwave-completion-help-info 
-	      (list 'keyword name type-selector class-selector))
+	      (list 'keyword name type-selector class-selector nil super-classes))
 	 'keyword 'keyword list nil
 	 (format "Select keyword for function %s%s" msg-name
      (t (error "This should not happen (idlwave-complete)")))))
+(defvar idlwave-complete-special nil
+  "List of special completion functions.
+These functions are called for each completion.  Each function must check
+if its own special completion context is present.  If yes, it should
+use `idlwave-complete-in-buffer' to do some completion and return `t'.
+If such a function returns `t', *no further* attempts to complete
+other contexts will be done.  If the function returns `nil', other completions
+will be tried.")
+(defun idlwave-complete-special ()
+  (let ((functions idlwave-complete-special)
+	fun)
+    (catch 'exit
+      (while (setq fun (pop functions))
+	(if (funcall fun)
+	    (throw 'exit t)))
+      nil)))
 (defun idlwave-make-force-complete-where-list (what &optional module class)
   ;; Return an artificial WHERE specification to force the completion
   ;; routine to complete a specific item independent of context.
      ((eq what 'procedure-keyword)
       (let* ((class-selector nil)
+	     (super-classes nil)
 	     (type-selector 'pro)
 	     (pro (or module
      ((eq what 'function-keyword)
       (let* ((class-selector nil)
+	     (super-classes nil)
 	     (type-selector 'fun)
 	     (func (or module
      ((eq what 'procedure-method-keyword)
       (let* ((class (idlwave-determine-class class-list 'pro))
 	     (class-selector class)
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (type-selector 'pro)
 	     (pro (or module
      ((eq what 'function-method-keyword)
       (let* ((class (idlwave-determine-class class-list 'fun))
 	     (class-selector class)
+	     (super-classes (idlwave-all-class-inherits class-selector))
 	     (type-selector 'fun)
 	     (func (or module
 	     (throw 'exit match))
 	(setq list (cdr (memq match list)))))))
+(defun idlwave-rinfo-assq-any-class (name type class list)
+  (let* ((classes (cons class (idlwave-all-class-inherits class)))
+	 class rtn)
+    (while classes
+      (if (setq rtn (idlwave-rinfo-assq name type (pop classes) list))
+	  (setq classes nil)))
+    rtn))
 (defun idlwave-best-rinfo-assq (name type class list)
   "Like `idlwave-rinfo-assq', but get all twins and sort, then return first."
   (let ((twins (idlwave-routine-twins
-		(idlwave-rinfo-assq name type class list)
+		(idlwave-rinfo-assq-any-class name type class list)
     (when (> (length twins) 1)
 	      (idlwave-all-assq method (idlwave-routines)))
       (idlwave-uniquify rtn))))
+(defun idlwave-members-only (list club)
+  "Return list of all elements in LIST which are also in CLUB."
+  (let (rtn)
+    (while list
+      (if (member (car list) club)
+	  (setq rtn (cons (car list) rtn)))
+      (setq list (cdr list)))
+    (nreverse rtn)))
+(defun idlwave-nonmembers-only (list club)
+  "Return list of all elements in LIST which are not in CLUB."
+  (let (rtn)
+    (while list
+      (if (member (car list) club)
+	  nil
+	(setq rtn (cons (car list) rtn)))
+      (setq list (cdr list)))
+    (nreverse rtn)))
 (defun idlwave-determine-class (info type)
   ;; Determine the class of a routine call.  INFO is the structure returned
   ;; `idlwave-what-function' or `idlwave-what-procedure'.
 (defvar type-selector)
 (defvar class-selector)
 (defvar method-selector)
+(defvar super-classes)
 (defun idlwave-selector (a)
   (and (eq (nth 1 a) type-selector)
        (or (and (nth 2 a) (eq class-selector t))
-	   (eq (nth 2 a) class-selector))))
+	   (eq (nth 2 a) class-selector)
+	   (memq (nth 2 a) super-classes)
+	   )))
 (defun idlwave-where ()
   "Find out where we are.
      ((string-match "\\`[ \t]*\\(pro\\|function\\)\\>"
 		    (buffer-substring bos (point)))
-     ((string-match "OBJ_NEW([ \t]*['\"]\\([a-zA-Z][a-zA-Z0-9$_]*\\)?\\'"
+     ((string-match "OBJ_NEW([ \t]*['\"]\\([a-zA-Z0-9$_]*\\)?\\'"
+		    (buffer-substring bos (point)))
+      (setq cw 'class))                    
+     ((string-match "\\<inherits\\s-+\\([a-zA-Z0-9$_]*\\)?\\'"
 		    (buffer-substring bos (point)))
       (setq cw 'class))                    
      ((and func 
       ;; We cannot add something - offer a list.
       (message "Making completion list...")
       (let* ((list all-completions)
+	     ;; "complete" means, this is already a valid completion
 	     (complete (memq spart all-completions))
 	     (completion-highlight-first-word-only t) ; XEmacs
 	     (completion-fixup-function               ; Emacs
 				"Select a class" "class")))
 (defun idlwave-attach-classes (list is-kwd show-classes)
-  ;; attach the proper class list to a LIST of completion items.
+  ;; Attach the proper class list to a LIST of completion items.
   ;; IS-KWD, when non-nil, shows its keywords - otherwise its methods
   ;; SHOW-CLASSES is the value of `idlwave-completion-show-classes'.
   (catch 'exit
-    (if (or (null show-classes)         ; don't wnat to see classes
-	    (null class-selector)       ; not a method call
-	    (stringp class-selector))   ; the class is already known
+    (if (or (null show-classes)           ; don't want to see classes
+	    (null class-selector)         ; not a method call
+	    (and (stringp class-selector) ; the class is already known
+		 (not super-classes)))    ; no possibilities for inheritance
 	;; In these cases, we do not have to do anything
 	(throw 'exit list))
-    ;; The property and dots stuff currently only make sense with XEmacs
-    ;; because Emacs drops text properties when filling the *Completions*
-    ;; buffer.
-    (let* ((do-prop (and (featurep 'xemacs) (>= show-classes 0)))
+    ;; FIXME: props and dots for Emacs?  Seems to work fine.
+    (let* ((do-prop (and (>= show-classes 0)
+			 (>= emacs-major-version 21)))
 	   (do-buf (not (= show-classes 0)))
-	   (do-dots (featurep 'xemacs))
+	   ; (do-dots (featurep 'xemacs))
+	   (do-dots t)
+	   (inherit (if super-classes
+			(cons class-selector super-classes)))
 	   (max (abs show-classes))
 	   (lmax (if do-dots (apply 'max (mapcar 'length list))))
 	  classes nclasses class-info space)
 		    method-selector x type-selector)
 		 (idlwave-all-method-classes x type-selector)))
+	 (if inherit
+	     (setq classes 
+		   (delq nil
+			 (mapcar (lambda (x) (if (memq x inherit) x nil))
+				 classes))))
 	 (setq nclasses (length classes))
 	 ;; Make the separator between item and class-info
 	 (if do-dots
+;;; ------------------------------------------------------------------------
+;;; Sturucture parsing code, and code to manage class info
+;; - Go again over the documentation how to write a completion
+;;   plugin.  It is in self.el, but currently still very bad.
+;;   This could be in a separate file in the distribution, or 
+;;   in an appendix for the manual.  
+(defun idlwave-struct-tags ()
+  "Return a list of all tags in the structure defined at point.
+Point is expected just before the opening `{' of the struct definition."
+  (save-excursion
+    (let* ((borders (idlwave-struct-borders))
+	   (beg (car borders))
+	   (end (cdr borders))
+	   tags)
+      (goto-char beg)
+      (while (re-search-forward "[{,][ \t]*\\(\\$.*\n[ \t]*\\)?\\([a-zA-Z][a-zA-Z0-9_]*\\)[ \t]*:" end t)
+	;; Check if we are still on the top level of the structure.
+	(if (and (condition-case nil (progn (up-list -1) t) (error nil))
+		 (= (point) beg))
+	    (push (match-string 2) tags))
+	(goto-char (match-end 0)))
+      (nreverse tags))))
+(defun idlwave-struct-inherits ()
+  "Return a list of all `inherits' names in the struct at point.
+Point is expected just before the opening `{' of the struct definition."
+  (save-excursion
+    (let* ((borders (idlwave-struct-borders))
+	   (beg (car borders))
+	   (end (cdr borders))
+	   (case-fold-search t)
+	   names)
+      (goto-char beg)
+      (while (re-search-forward "[{,][ \t]*\\(\\$.*\n[ \t]*\\)?inherits[ \t]*\\(\\$.*\n[ \t]*\\)?\\([a-zA-Z][a-zA-Z0-9_]*\\)" end t)
+	;; Check if we are still on the top level of the structure.
+	(if (and (condition-case nil (progn (up-list -1) t) (error nil))
+		 (= (point) beg))
+	    (push (match-string 3) names))
+	(goto-char (match-end 0)))
+      (nreverse names))))
+(defun idlwave-struct-borders ()
+  "Return the borders of the {...} after point as a cons cell."
+  (let (beg)
+    (save-excursion
+      (skip-chars-forward "^{")
+      (setq beg (point))
+      (condition-case nil (forward-list 1)
+	(error (goto-char beg)))
+      (cons beg (point)))))
+(defun idlwave-find-structure-definition (&optional var name bound)
+  "Search forward for a structure definition.
+If VAR is non-nil, search for a structure assigned to variable VAR.
+If NAME is non-nil, search for a named structure NAME.
+If BOUND is an integer, limit the search.
+If BOUND is the symbol `all', we search first back and then forward
+through the entire file."
+  (let* ((ws "[ \t]*\\(\\$.*\n[ \t]*\\)?")
+	 (lim (if (integerp bound) bound nil))
+	 (re (concat
+	      (if var (concat "\\<" (regexp-quote var) "\\>" ws) "\\(\\)")
+	      "=" ws "\\({\\)"
+	      (if name (concat ws "\\<" name "\\>") ""))))
+    (if (or (and (eq bound 'all)
+		 (re-search-backward re nil t))
+	    (re-search-forward re lim t))
+	(goto-char (match-beginning 3)))))
+(defvar idlwave-class-info nil)
+(defvar idlwave-system-class-info nil)
+(add-hook 'idlwave-update-rinfo-hook
+	  (lambda () (setq idlwave-class-info nil)))
+;; FIXME:  Is that really needed?
+(add-hook 'idlwave-after-load-rinfo-hook
+	  (lambda () (setq idlwave-class-info nil)))
+(defun idlwave-class-info (class)
+  (let (list entry)
+    (unless idlwave-class-info
+      ;; Info is nil, put in the system stuff.
+      (setq idlwave-class-info idlwave-system-class-info)
+      (setq list idlwave-class-info)
+      (while (setq entry (pop list))
+	(idlwave-sintern-class-info entry)))
+    (setq class (idlwave-sintern-class class))
+    (setq entry (assq class idlwave-class-info))
+    (unless entry
+      (setq entry (idlwave-find-class-info class))
+      (when entry
+	;; Sintern and cache the info
+	(idlwave-sintern-class-info entry)
+	(push entry idlwave-class-info)))
+    entry))
+(defun idlwave-sintern-class-info (entry)
+  "Sintern the class names in a class-info entry."
+  (let ((taglist (assq 'tags entry))
+	(inherits (assq 'inherits entry)))
+    (setcar entry (idlwave-sintern-class (car entry) 'set))
+    (if inherits
+	(setcdr inherits (mapcar (lambda (x) (idlwave-sintern-class x 'set))
+				 (cdr inherits))))))
+(defun idlwave-find-class-info (class)
+  "Find the __define procedure for a class structure and return info entry."
+  (let* ((pro (concat (downcase class) "__define"))
+	 (class (idlwave-sintern-class class))
+	 (idlwave-auto-routine-info-updates nil)
+	 (file (cdr (nth 3 (idlwave-rinfo-assoc pro 'pro nil 
+						(idlwave-routines)))))
+	 buf)
+    (if (or (not file)
+	    (not (file-regular-p 
+		  (setq file (idlwave-expand-lib-file-name file)))))
+	nil ; Cannot get info
+      (save-excursion
+	(if (setq buf (idlwave-get-buffer-visiting file))
+	    (set-buffer buf)
+	  (set-buffer (get-buffer-create " *IDLWAVE-tmp*"))
+	  (erase-buffer)
+	  (unless (eq major-mode 'idlwave-mode)
+	    (idlwave-mode))
+	  (insert-file-contents file))
+	(save-excursion
+	  (goto-char 1)
+	  (setq case-fold-search t)
+	  (when (and (re-search-forward
+		      (concat "^[ \t]*pro[ \t]+" pro "\\>") nil t)
+		     ;; FIXME: should we limit to end of pro here?
+		     (idlwave-find-structure-definition nil class))
+	    (list class
+		  (cons 'tags (idlwave-struct-tags))
+		  (cons 'inherits (idlwave-struct-inherits)))))))))
+(defun idlwave-class-tags (class)
+  "Return the native tags in CLASS."
+  (cdr (assq 'tags (idlwave-class-info class))))
+(defun idlwave-class-inherits (class)
+  "Return the direct superclasses of CLASS."
+  (cdr (assq 'inherits (idlwave-class-info class))))
+(defun idlwave-all-class-tags (class)
+  "Return a list of native and inherited tags in CLASS."
+  (apply 'append (mapcar 'idlwave-class-tags
+			 (cons class (idlwave-all-class-inherits class)))))
+(defun idlwave-all-class-inherits (class)
+  "Return a list of all superclasses of CLASS (recursively expanded).
+The list is cashed in `idlwave-class-info' for faster access."
+  (cond
+   ((not idlwave-support-inheritance) nil)
+   ((eq class nil) nil)
+   ((eq class t) nil)
+   (t
+    (let ((info (idlwave-class-info class))
+	  entry)
+      (if (setq entry (assq 'all-inherits info))
+	  (cdr entry)
+	(let ((inherits (idlwave-class-inherits class))
+	      rtn all-inherits cl)
+	  (while inherits
+	    (setq cl (pop inherits)
+		  rtn (cons cl rtn)
+		  inherits (append inherits (idlwave-class-inherits cl))))
+	  (setq all-inherits (nreverse rtn))
+	  (nconc info (list (cons 'all-inherits all-inherits)))
+	  all-inherits))))))
+;; Completing class structure tags.  This is a completion plugin.
+;; The necessary taglist is constructed dynamically
+(defvar idlwave-current-tags-class nil)
+(defvar idlwave-current-class-tags nil)
+(defvar idlwave-current-native-class-tags nil)
+(defvar idlwave-sint-classtags nil)
+(idlwave-new-sintern-type 'classtag)
+(add-to-list 'idlwave-complete-special 'idlwave-complete-class-structure-tag)
+(add-hook 'idlwave-update-rinfo-hook 'idlwave-classtag-reset)
+(defun idlwave-complete-class-structure-tag ()
+  "Complete a structure tag on a `self' argument in an object method."
+  (interactive)
+  (let ((pos (point))
+	(case-fold-search t))
+    (if (save-excursion
+	  ;; Check if the context is right
+	  (skip-chars-backward "[a-zA-Z0-9._$]")
+	  (and (< (point) (- pos 4))
+	       (looking-at "self\\.")))
+	(let* ((class (nth 2 (idlwave-current-routine))))
+	  ;; Check if we are in a class routine
+	  (unless class
+	    (error "Not in a method procedure or function."))
+	  ;; Check if we need to update the "current" class
+	  (if (not (equal class idlwave-current-tags-class))
+	      (idlwave-prepare-class-tag-completion class))
+	  (setq idlwave-completion-help-info nil)
+	  (let  ((idlwave-cpl-bold idlwave-current-native-class-tags))
+	    (idlwave-complete-in-buffer
+	     'classtag 'classtag 
+	     idlwave-current-class-tags nil
+	     (format "Select a tag of class %s" class)
+	     "class tag"))
+	  t) ; return t to skip other completions
+      nil)))
+(defun idlwave-classtag-reset ()
+  (setq idlwave-current-tags-class nil))
+(defun idlwave-prepare-class-tag-completion (class)
+  "Find and parse the necessary class definitions for class structure tags."
+  (setq idlwave-sint-classtags nil)
+  (setq idlwave-current-tags-class class)
+  (setq idlwave-current-class-tags
+	(mapcar (lambda (x)
+		  (list (idlwave-sintern-classtag x 'set)))
+		(idlwave-all-class-tags class)))
+  (setq idlwave-current-native-class-tags
+	(mapcar 'downcase (idlwave-class-tags class))))
+;; Completing system variables and their structure fields
+;; This is also a plugin.  It is a bit bigger since we support loading
+;; current system variables from the shell and highlighting in the
+;; completions buffer. 
+(defvar idlwave-sint-sysvars nil)
+(defvar idlwave-sint-sysvartags nil)
+(idlwave-new-sintern-type 'sysvar)
+(idlwave-new-sintern-type 'sysvartag)
+(add-to-list 'idlwave-complete-special 'idlwave-complete-sysvar-or-tag)
+(add-hook 'idlwave-update-rinfo-hook 'idlwave-sysvars-reset)
+(add-hook 'idlwave-after-load-rinfo-hook 'idlwave-remember-builtin-sysvars)
+(add-hook 'idlwave-after-load-rinfo-hook 'idlwave-sintern-sysvar-alist)
+(defvar idlwave-system-variables-alist nil
+  "Alist of system variables and the associated structure tags.
+Gets set in `idlw-rinfo.el'.")
+(defvar idlwave-builtin-system-variables nil)
+(defun idlwave-complete-sysvar-or-tag ()
+  "Complete a system variable."
+  (interactive)
+  (let ((pos (point))
+	(case-fold-search t))
+    (cond ((save-excursion
+	     ;; Check if the context is right for system variable
+	     (skip-chars-backward "[a-zA-Z0-9_$]")
+	     (equal (char-before) ?!))
+	   (setq idlwave-completion-help-info '(idlwave-complete-sysvar-help))
+	   (idlwave-complete-in-buffer 'sysvar 'sysvar 
+				       idlwave-system-variables-alist nil
+				       "Select a system variable"
+				       "system variable")
+	   t)  ; return t to skip other completions
+	  ((save-excursion
+	     ;; Check if the context is right for sysvar tag
+	     (skip-chars-backward "[a-zA-Z0-9_$.]")
+	     (and (equal (char-before) ?!)
+		  (looking-at "\\([a-zA-Z][a-zA-Z0-9_$]*\\)\\.")
+		  (<= (match-end 0) pos)))
+	   ;; Complete a system variable tag
+	   (let* ((var (idlwave-sintern-sysvar (match-string 1)))
+		  (entry (assq var idlwave-system-variables-alist))
+		  (tags (cdr entry)))
+	     (or entry (error "!%s is not know to be a system variable" var))
+	     (or tags (error "System variable !%s is not a structure" var))
+	     (setq idlwave-completion-help-info
+		   (list 'idlwave-complete-sysvar-help var))
+	     (idlwave-complete-in-buffer 'sysvartag 'sysvartag 
+					 tags nil
+					 "Select a system variable tag"
+					 "system variable tag")
+	     t)) ; return t to skip other completions
+	  (t nil))))
+(defvar name) 
+(defvar kwd)
+(defun idlwave-complete-sysvar-help (mode word)
+  (cond
+   ((eq mode 'test)
+    (or (and (eq nil (nth 1 idlwave-completion-help-info))
+	     (member (downcase word) idlwave-builtin-system-variables))
+	(and (stringp (nth 1 idlwave-completion-help-info))
+	     (member (downcase (nth 1 idlwave-completion-help-info))
+		     idlwave-builtin-system-variables))))
+   ((eq mode 'set)
+    (setq name "system variables"
+	  kwd (concat "!"
+		      (if (stringp (nth 1 idlwave-completion-help-info))
+			  (nth 1 idlwave-completion-help-info)
+			word))))
+   (t (error "This should not happen"))))
+(defun idlwave-sysvars-reset ()
+  (if (and (fboundp 'idlwave-shell-is-running)
+	   (idlwave-shell-is-running))
+      (idlwave-shell-send-command "idlwave_get_sysvars"
+				  'idlwave-process-sysvars 'hide)))
+(defun idlwave-process-sysvars ()
+  (idlwave-shell-filter-sysvars)
+  (setq idlwave-sint-sysvars nil
+	idlwave-sint-sysvartags nil)
+  (idlwave-sintern-sysvar-alist))
+(defun idlwave-remember-builtin-sysvars ()
+  (setq idlwave-builtin-system-variables
+	(mapcar 'downcase 
+		(mapcar 'car idlwave-system-variables-alist))))
+(defun idlwave-sintern-sysvar-alist ()
+  (let ((list idlwave-system-variables-alist) entry)
+    (while (setq entry (pop list))
+      (setcar entry (idlwave-sintern-sysvar (car entry) 'set))
+      (setcdr entry (mapcar (lambda (x) 
+			      (list (idlwave-sintern-sysvartag (car x) 'set)))
+			    (cdr entry))))))
+(defvar idlwave-shell-command-output)
+(defun idlwave-shell-filter-sysvars ()
+  "Get the system variables and structure tags."
+  (let ((text idlwave-shell-command-output)
+	(start 0)
+	(old idlwave-system-variables-alist)
+	var tags type name class)
+    (setq idlwave-system-variables-alist nil)
+    (while (string-match "^IDLWAVE-SYSVAR: !\\([a-zA-Z0-9_$]+\\)\\( \\(.*\\)\\)?"
+			 text start)
+      (setq start (match-end 0)
+	    var (match-string 1 text)
+	    tags (if (match-end 3) (split-string (match-string 3 text))))
+      (setq idlwave-system-variables-alist
+	    (cons (cons var (mapcar 'list tags))
+		  idlwave-system-variables-alist)))
+    ;; Keep the old value if query was not successful
+    (setq idlwave-system-variables-alist
+	  (or idlwave-system-variables-alist old))))
 (defun idlwave-completion-fontify-classes ()
   "Goto the *Completions* buffer and fontify the class info."
   (when (featurep 'font-lock)
   (let ((name1 (idlwave-make-full-name class name))
 	source buf1 entry
 	(buf (current-buffer))
-	(pos (point)))
+	(pos (point))
+	name2)
     (setq entry (idlwave-best-rinfo-assq name type class (idlwave-routines))
-	  source (or force-source (nth 3 entry)))
+	  source (or force-source (nth 3 entry))
+	  name2 (if (nth 2 entry)
+		    (idlwave-make-full-name (nth 2 entry) name)
+		  name1))		  
      ((or (null name) (equal name ""))
       (error "Abort"))
      ((null entry)
-      (error "Nothing known about a module %s" name1))
+      (error "Nothing known about a module %s" name2))
      ((eq (car source) 'system)
       (error "Source code for system routine %s is not available." 
-	     name1))
+	     name2))
      ((equal (cdr source) "")
       (error "Source code for routine %s is not available."
-	     name1))
+	     name2))
      ((memq (car source) '(buffer lib compiled))
       (setq buf1 
 	    (if (eq (car source) 'lib)
 			   ((equal type "p") "pro")
 			   (t "\\(pro\\|function\\)"))
 		     "\\>[ \t]+" 
-		     (regexp-quote (downcase name1))
+		     (regexp-quote (downcase name2))
 	     nil t)
 	    (goto-char (match-beginning 0))
 	  (pop-to-buffer buf)
 	  (goto-char pos)
-	  (error "Could not find routine %s" name1)))))))
+	  (error "Could not find routine %s" name2)))))))
 (defun idlwave-what-module ()
   "Return a default module for stuff near point.
 	(list pro 'pro (idlwave-determine-class (nth 0 where) 'pro)))
        (t nil)))))
+(defun idlwave-what-module-find-class ()
+  "Call idlwave-what-module and find the inherited class if necessary."
+  (let* ((module (idlwave-what-module))
+	 (class (nth 2 module))
+	 classes)
+    (if (and (= (length module) 3)
+	     (stringp class))
+	(list (car module)
+	      (nth 1 module)
+	      (apply 'idlwave-find-inherited-class module))
+      module)))
+(defun idlwave-find-inherited-class (name type class)
+  "Find the class which defines TYPE NAME and is CLASS or inherited by CLASS."
+  (let ((entry (idlwave-best-rinfo-assoc name type class (idlwave-routines))))
+    (if entry
+	(nth 2 entry)
+      class)))
 (defun idlwave-fix-keywords (name type class keywords)
   ;; This fixes the list of keywords.
   (let ((case-fold-search t)
 	     (mapcar (lambda (k) (add-to-list 'keywords k))
 		     (nth 5 x))))
       (setq keywords (idlwave-uniquify keywords)))
+    ;; If we have inheritance, add all keywords from superclasses
+    ;; :-(  Taken out because JD says it does not work this way.
+;    (when (and (stringp class)
+;	       (or (assq (idlwave-sintern-keyword "_extra") keywords)
+;		   (assq (idlwave-sintern-keyword "_ref_extra") keywords))
+;	       (boundp 'super-classes))
+;      (loop for x in (idlwave-routines) do
+;	(and (nth 2 x)                           ; non-nil class
+;	     (or (eq (nth 2 x) class)            ; the right class
+;		 (memq (nth 2 x) super-classes)) ; an inherited class
+;	     (or (and (eq (nth 1 x) type)        ; default type
+;		      (eq (car x) name))         ; default name
+;		 (and (eq (nth 1 x) type1)       ; backup type
+;		      (eq (car x) name1)))       ; backup name
+;	     (mapcar (lambda (k) (add-to-list 'keywords k))
+;		     (nth 5 x))))
+;      (setq keywords (idlwave-uniquify keywords)))
     ;; Return the final list
     (when (window-live-p ri-window)
       (delete-window ri-window))))
-(defun idlwave-display-calling-sequence (name type class)
+(defun idlwave-display-calling-sequence (name type class
+					      &optional initial-class)
   ;; Display the calling sequence of module NAME, type TYPE in class CLASS.
-  (let* ((entry (or (idlwave-best-rinfo-assq name type class
+  (let* ((initial-class (or initial-class class))
+	 (entry (or (idlwave-best-rinfo-assq name type class
 		    (idlwave-rinfo-assq name type class 
 	 (name (or (car entry) name))
 	 (class (or (nth 2 entry) class))
+	 (superclasses (idlwave-all-class-inherits initial-class))
 	 (twins (idlwave-routine-twins entry))
 	 (dtwins (idlwave-study-twins twins))
 	 (all dtwins)
 	  (if (idlwave-help-directory)
 	      "Button2: Pop to source and back.             Button3: Source in Help window."
 	    "Button2: Pop to source and back."))
+	 (help-echo-class
+	  "Button2: Display info about same method in superclass")
 	 (col 0)
-	 (data (list name type class (current-buffer) olh))
+	 (data (list name type class (current-buffer) olh initial-class))
 	 (km-prop (if (featurep 'xemacs) 'keymap 'local-map))
 	 (face 'idlwave-help-link-face)
 	 beg props win cnt total)
     (setq keywords (idlwave-fix-keywords name type class keywords))
      ((null entry)
-      (error "No %s %s known" type name))
+      (error "No %s %s known %s" type name
+	     (if initial-class (concat "in class " initial-class) "")))
      ((or (null name) (equal name ""))
       (error "No function or procedure call at point."))
      ((null calling-seq)
 	(set (make-local-variable 'idlwave-popup-source) nil)
 	(set (make-local-variable 'idlwave-current-obj_new-class)
+	(when superclasses
+	  (setq props (list 'mouse-face 'highlight
+			    km-prop idlwave-rinfo-mouse-map
+			    'help-echo help-echo-class
+			    'data (cons 'class data)))
+	  (let ((classes (cons initial-class superclasses)) c)
+	    (insert "Classes: ")
+	    (while (setq c (pop classes))
+	      (insert " ")
+	      (setq beg (point))
+	      (insert c)
+	      (if (equal (downcase c) (downcase class))
+		  (add-text-properties beg (point) (list 'face 'bold))
+		(if (idlwave-rinfo-assq name type c (idlwave-routines))
+		    (add-text-properties beg (point) props))))
+	    (insert "\n")))
 	(setq props (if have-olh
 			(list 'mouse-face 'highlight
 			      km-prop idlwave-rinfo-mouse-map
 was pressed."
   (interactive "e")
   (if ev (mouse-set-point ev))
-  (let (data id name type class buf keyword bufwin source)
+  (let (data id name type class buf keyword bufwin source word initial-class)
     (setq data (get-text-property (point) 'data)
 	  source (get-text-property (point) 'source)
 	  keyword (get-text-property (point) 'keyword)
 	  id (car data)
 	  name (nth 1 data) type (nth 2 data) class (nth 3 data)
 	  buf (nth 4 data)
+	  initial-class (nth 6 data)
+	  word (idlwave-this-word)
 	  bufwin (get-buffer-window buf t))
-    (cond ((eq id 'usage)
+    (cond ((eq id 'class)
+	   (if (window-live-p bufwin) (select-window bufwin))
+	   (idlwave-display-calling-sequence 
+	    (idlwave-sintern-method name)
+	    type (idlwave-sintern-class word) 
+	    initial-class))
+	  ((eq id 'usage)
 	   (idlwave-online-help nil name type class))
 	  ((eq id 'source)
 ;;; idlwave.el ends here

File idlwave.texi

 @synindex ky cp
 @syncodeindex vr cp
 @syncodeindex fn cp
-@set VERSION 4.2
-@set EDITION 4.2
+@set VERSION 4.4
+@set EDITION 4.4
 @set IDLVERSION 5.3
-@set DATE June 2000
+@set DATE October 2000
 @set AUTHOR Carsten Dominik
 @set MAINTAINER Carsten Dominik
 @kbd{C-c ?} was called.  If you use the @emph{right} mouse button, the
 source will not be visited by a buffer, but displayed in the online help
+@item @i{Classes}
+@tab The @i{Classes} line is only included in the routine info window if
+the current class inherits from other classes.  You can click with the
+@emph{middle} mouse button to display routine info about the current
+method in other classes on the inheritance chain.
 @end multitable
 @defopt idlwave-resize-routine-help-window (@code{t})
 The face for links to IDLWAVE online help.
 @end defopt
+@defopt idlwave-help-activate-links-agressively (@code{t})
+Non-@code{nil} means, make all possible links in help window active.
+@end defopt
 @node Completion, Routine Source, Online Help, The IDLWAVE Major Mode
 @section Completion
 @cindex Completion
 x = obj_new('MyCl',a*   @r{Keyword to @code{Init} method in class @code{MyCl}}
 pro A*                  @r{Class name}
 pro *                   @r{Fill in @code{Class::} of first method in this file}
+!v*                     @r{System variable}
+!version.t*             @r{Structure tag of system variable}
+self.g*                 @r{Class structure tag in methods}
 @end example
 @cindex Scrolling the @file{*Completions*} window
 will be shown next to the item (see option
 @code{idlwave-completion-show-classes}).  As a special case, the class
 of an object called @samp{self} object is always the class of the
-current routine.
+current routine.  All classes it inherits from are considered as well
+where appropriate.
 @cindex Forcing class query.
 @cindex Class query, forcing
 default - the variable @code{idlwave-store-inquired-class} can be used
 to turn it on.
+@defopt idlwave-support-inheritance (@code{t})
+Non-@code{nil} means, treat inheritance with completion, online help etc.
+@end defopt
 @defopt idlwave-completion-show-classes (@code{1})
 Non-@code{nil} means, show classes in @file{*Completions*} buffer when
 completing object methods and keywords.