Commits

dominik  committed 85b9b33

idlwave 5.1

  • Participants
  • Parent commits 9297f79

Comments (0)

Files changed (1)

File idlw-help.el

+;;; idlw-help.el --- Help code for IDLWAVE
+;; Copyright (c) 2000 Carsten Dominik
+;; Copyright (c) 2001, 2002 J.D. Smith
+;; Copyright (c) 2003 Free Software Foundation
+;;
+;; Authors: Carsten Dominik <dominik@astro.uva.nl>
+;;          J.D. Smith <jdsmith@as.arizona.edu>
+;; Maintainer: J.D. Smith <jdsmith@as.arizona.edu>
+;; Version: 5.1
+
+;; This file is part of GNU Emacs.
+
+;; This file 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.
+
+;; This file 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.
+
+;;; Commentary:
+
+;; The help link information for IDLWAVE's online help feature for
+;; system routines is extracted automatically from the IDL
+;; documentation, and is available, along with general routine
+;; information, in the file idlw-rinfo.el.  The HTML help file
+;; themselves are not distributable with Emacs, but are available,
+;; along with new versions of IDLWAVE, documentation, and more
+;; information, at:
+;;
+;;           http://idlwave.org
+;; 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;; Code:
+
+(eval-when-compile (require 'browse-url))
+
+(defgroup idlwave-online-help nil
+  "Online Help options for IDLWAVE mode."
+  :group 'idlwave)
+
+(defcustom idlwave-html-help-location 
+  (if (memq system-type '(ms-dos windows-nt))
+      nil
+    "/usr/local/etc/")
+  "The directory where the idl_html_help/ dir or idl.chm help file
+(Windows only) lives."
+  :group 'idlwave-online-help
+  :type 'directory)
+
+(defcustom idlwave-help-use-hh nil
+  "Whether to use the HTMLHelp viewer with idl.chm (Windows only)."
+  :group 'idlwave-online-help
+  :type '(choice :tag "use help viewer"
+		 (const :tag "<none>" nil)
+		 (const :tag "hh" 'hh)
+		 (const :tag "keyhh" 'keyhh)))
+
+(defcustom idlwave-help-browser-function browse-url-browser-function
+  "Function to use to display html help.
+Defaults to `browse-url-browser-function', which see."
+  :group 'idlwave-online-help
+  :type 'function)
+
+(defcustom idlwave-help-browser-generic-program browse-url-generic-program
+  "Program to run if using browse-url-generic-program."
+  :group 'idlwave-online-help
+  :type 'string)
+
+(defcustom idlwave-help-browser-generic-args 
+  (if (boundp 'browse-url-generic-args)
+      browse-url-generic-args "")
+  "Program args to use if using browse-url-generic-program."
+  :group 'idlwave-online-help
+  :type 'string)
+
+(defcustom idlwave-help-browser-is-local nil
+  "Whether the browser will display locally in an Emacs window.
+Several browsers run and/or display inside Emacs windows, but most are
+external programs.  If the browser name contains \"-w3\", it is
+assumed to be local to Emacs.  For other local browsers, this variable
+must be explicitly set non-nil in order for the variable
+`idlwave-help-use-dedicated-frame' to function."
+  :group 'idlwave-online-help
+  :type 'boolean)
+
+(defvar idlwave-help-directory ""
+  "Obsolete variable.  See idlwave-html-help-location.")
+
+(defcustom idlwave-help-use-dedicated-frame t
+  "*Non-nil means, use a separate frame for Online Help if possible."
+  :group 'idlwave-online-help
+  :type 'boolean)
+
+(defcustom idlwave-help-frame-parameters
+  '((height . 32) (unsplittable . t))
+  "The frame parameters for the special Online Help frame.
+See also `idlwave-help-use-dedicated-frame'.
+If you do not set the frame width here, the value specified in
+`idlw-help.el' will be used."
+  :group 'idlwave-online-help
+  :type '(repeat
+	  (cons symbol sexp)))
+
+(defcustom idlwave-max-popup-menu-items 20
+  "Maximum number of items per pane in popup menus.
+Currently only used for class selection during completion help."
+  :group 'idlwave-online-help
+  :type 'integer)
+
+(defcustom idlwave-extra-help-function 'idlwave-help-with-source
+  "The function to call for online help if the normal help fails.
+Online help works only for system routines which are described in the
+IDL manuals.  A function may be specified to access help from other sources.
+
+The function must accept four arguments: NAME, TYPE, CLASS, KEYWORD.
+The Help buffer is current when this function is called, and the help
+text should be loaded into this buffer.  If help is found, the
+function should return the buffer position which should be used as
+`window-start' in the help window.  Also, the variable
+`idlwave-help-mode-line-indicator' should be set to a useful string,
+which will be displayed in the mode line of the help window.  If
+should also set the variable `idlwave-help-min-frame-width' to a
+positive integer.  IDLWAVE will ensure that the help frame is at least
+that many columns wide.  Failure to find help should be indicated by
+throwing an error.
+
+When this variable is non-nil, IDLWAVE will allow the mouse-3 help click
+for every routine and keyword, even though the item may not be highlighted
+in blue (indicating the availability of system documentation).
+
+The default value for this function is `idlwave-help-with-source' which
+loads the routine source file into the help buffer.  If you try to write
+a different function which accesses a special help file or so, it is
+probably a good idea to still call this function as a fallback."
+  :group 'idlwave-online-help
+  :type 'symbol)
+
+(defcustom idlwave-help-fontify-source-code nil
+  "*Non-nil means, fontify source code displayed as help like normal code."
+  :group 'idlwave-online-help
+  :type 'boolean)
+
+(defcustom idlwave-help-source-try-header t
+  "*Non-nil means, try to find help in routine header when displaying source.
+Routines which are not documented in the system manual use their source as
+help text.  When this variable is non-nil, we try to find a description of
+the help item in the first routine doclib header above the routine definition.
+If the variable is nil, or if we cannot find/parse the header, the routine
+definition is displayed instead."
+  :group 'idlwave-online-help
+  :type 'boolean)
+
+
+(defcustom idlwave-help-doclib-name "name"
+  "*A regexp for the heading word to search for in doclib headers
+which specifies the `name' section.  Can be used for localization
+support."
+  :group 'idlwave-online-help
+  :type 'string)
+
+(defcustom idlwave-help-doclib-keyword "KEYWORD"
+  "*A regexp for the heading word to search for in doclib headers
+which specifies the `keywords' section.  Can be used for localization
+support."
+  :group 'idlwave-online-help
+  :type 'string)
+
+(defface idlwave-help-link-face
+  '((((class color)) (:foreground "Blue"))
+    (t (:weight bold)))
+  "Face for highlighting links into IDLWAVE online help."
+  :group 'idlwave-online-help)
+
+(defvar idlwave-help-activate-links-aggressively nil
+  "Obsolete variable.")
+  
+(defvar idlwave-completion-help-info)
+
+(defvar idlwave-help-frame nil
+  "The frame for display of IDL online help.")
+(defvar idlwave-help-frame-width 102
+  "The default width of the help frame.")
+
+(defvar idlwave-html-help-is-available nil
+  "Is the system online help text avaiable?")
+
+(defvar idlwave-help-mode-line-indicator ""
+  "Used for the special mode line in the idlwave-help-mode.")
+
+(defvar idlwave-help-window-configuration nil)
+(defvar idlwave-help-special-topic-words nil) ; defined by get_rinfo
+
+;; Define the key bindings for the Help application
+
+(defvar idlwave-help-mode-map (make-sparse-keymap)
+  "The keymap used in idlwave-help-mode.")
+
+(define-key idlwave-help-mode-map "q" 'idlwave-help-quit)
+(define-key idlwave-help-mode-map "w" 'widen)
+(define-key idlwave-help-mode-map "\C-m" (lambda (arg)
+					   (interactive "p")
+					   (scroll-up arg)))
+(define-key idlwave-help-mode-map " " 'scroll-up)
+(define-key idlwave-help-mode-map [delete] 'scroll-down)
+(define-key idlwave-help-mode-map "h" 'idlwave-help-find-header)
+(define-key idlwave-help-mode-map "H" 'idlwave-help-find-first-header)
+(define-key idlwave-help-mode-map "." 'idlwave-help-toggle-header-match-and-def)
+(define-key idlwave-help-mode-map "F" 'idlwave-help-fontify)
+(define-key idlwave-help-mode-map "\M-?" 'idlwave-help-return-to-calling-frame)
+(define-key idlwave-help-mode-map "x" 'idlwave-help-return-to-calling-frame)
+
+;; Define the menu for the Help application
+
+(easy-menu-define
+  idlwave-help-menu idlwave-help-mode-map
+  "Menu for Help IDLWAVE system"
+  '("IDLHelp"
+    ["Definition <-> Help Text" idlwave-help-toggle-header-match-and-def t]
+    ["Find DocLib Header" idlwave-help-find-header t]
+    ["Find First DocLib Header" idlwave-help-find-first-header t]
+    ["Fontify help buffer" idlwave-help-fontify t]
+    "--"
+    ["Quit" idlwave-help-quit t]))
+
+(defun idlwave-help-mode ()
+  "Major mode for displaying IDL Help.
+
+This is a VIEW mode for the ASCII version of IDL Help files,
+with some extras.  Its main purpose is speed - so don't
+expect a fully hyper-linked help.
+
+Scrolling:          SPC  DEL  RET
+Text Searches:      Inside Topic: Use Emacs search functions
+Exit:               [q]uit or mouse button 3 will kill the frame
+
+When the hep text is a source file, the following commands are available
+
+Fontification:      [F]ontify the buffer like source code
+Jump:               [h] to function doclib header
+                    [H] to file doclib header
+                    [.] back and forward between header and definition
+
+Here are all keybindings.
+\\{idlwave-help-mode-map}"
+  (kill-all-local-variables)
+  (buffer-disable-undo)
+  (setq major-mode 'idlwave-help-mode
+	mode-name "IDLWAVE Help")
+  (use-local-map idlwave-help-mode-map)
+  (easy-menu-add idlwave-help-menu idlwave-help-mode-map)
+  (setq truncate-lines t)
+  (setq case-fold-search t)
+  (setq mode-line-format
+	(list ""
+	      'mode-line-modified
+	      'mode-line-buffer-identification
+	      ":  " 'idlwave-help-mode-line-indicator
+	      " -%-"))
+  (setq buffer-read-only t)
+  (set (make-local-variable 'idlwave-help-def-pos) nil)
+  (set (make-local-variable 'idlwave-help-args) nil)
+  (set (make-local-variable 'idlwave-help-in-header) nil)
+  (run-hooks 'idlwave-help-mode-hook))
+
+(defun idlwave-html-help-location ()
+  "Return the help directory where HTML files are, or nil if that is unknown."
+  (or (and (stringp idlwave-html-help-location)
+	   (> (length idlwave-html-help-location) 0)
+	   (file-directory-p idlwave-html-help-location)
+	   idlwave-html-help-location)
+      (getenv "IDLWAVE_HELP_LOCATION")
+      (and (memq system-type '(ms-dos windows-nt)) ; Base it on sysdir
+	   idlwave-help-use-hh
+	   (stringp idlwave-system-directory)
+	   (> (length idlwave-system-directory) 0)
+	   (file-directory-p idlwave-system-directory)
+	   (expand-file-name "HELP" idlwave-system-directory))))
+
+(defvar idlwave-current-obj_new-class)
+(defvar idlwave-help-diagnostics)
+(defvar idlwave-experimental)
+(defvar idlwave-last-context-help-pos)
+(defun idlwave-do-context-help (&optional arg)
+  "Wrapper around the call to idlwave-context-help1.
+It collects and prints the diagnostics messages."
+  (let ((marker (list (current-buffer) (point)))
+	(idlwave-help-diagnostics nil))
+    ;; Check for frame switching.  When the command is invoked twice
+    ;; at the same position, we try to switch to the help frame
+    ;; FIXME:  Frame switching works only on XEmacs
+    (if (and idlwave-experimental
+	     (equal last-command this-command)
+	     (equal idlwave-last-context-help-pos marker))
+	(idlwave-help-select-help-frame)
+      ;; Do the real thing.
+      (setq idlwave-last-context-help-pos marker)
+      (idlwave-do-context-help1 arg)
+      (if idlwave-help-diagnostics
+	  (message "%s" (mapconcat 'identity 
+				   (nreverse idlwave-help-diagnostics)
+				   "; "))))))
+
+(defvar idlwave-help-do-class-struct-tag nil)
+(defvar idlwave-help-do-struct-tag nil)
+(defun idlwave-do-context-help1 (&optional arg)
+  "The work-horse version of `idlwave-context-help', which see."
+  (save-excursion
+    (if (equal (char-after) ?/) 
+	(forward-char 1)
+      (if (equal (char-before) ?=)
+	  (backward-char 1)))
+    (let* ((idlwave-query-class nil)
+	   (idlwave-force-class-query (equal arg '(4)))
+	   (chars "a-zA-Z0-9_$.!")
+	   (beg (save-excursion (skip-chars-backward chars) (point)))
+	   (end (save-excursion (skip-chars-forward chars) (point)))
+	   (this-word (buffer-substring-no-properties beg end))
+	   (st-ass (assoc (downcase this-word) 
+			  idlwave-help-special-topic-words))
+	   (classtag (and (string-match "self\\." this-word)
+			  (< beg (- end 4))))
+	   (structtag (and (fboundp 'idlwave-complete-structure-tag)
+			   (string-match "\\`\\([^.]*\\)\\." this-word)
+			   (< beg (- end 4))))
+	   module keyword cw mod1 mod2 mod3)
+      (if (or arg 
+	      (and (not st-ass)
+		   (not classtag)
+		   (not structtag)
+		   (not (member (string-to-char this-word) '(?! ?.)))))
+	  ;; Need the module information
+	  (progn
+	    ;; MODULE is (name type class), for this or any inheriting class
+	    (setq module (idlwave-what-module-find-class)
+		  cw (nth 2 (idlwave-where))) ;what would we complete here?
+	    ;; Correct for OBJ_NEW, we may need an INIT method instead.
+	    (if (equal (idlwave-downcase-safe (car module)) "obj_new")
+		(let* ((bos (save-excursion (idlwave-beginning-of-statement)
+					    (point)))
+		       (str (buffer-substring bos (point))))
+		  (if (string-match "OBJ_NEW([ \t]*['\"]\\([a-zA-Z][a-zA-Z0-9$_]+\\)['\"]" str)
+		      (setq module (list "init" 'fun (match-string 1 str))
+			    idlwave-current-obj_new-class (match-string 1 str))
+		    )))))
+      (cond (arg (setq mod1 module))
+	    	    
+	    ;; A special topic -- only system help
+            (st-ass (setq mod1 (list (cdr st-ass))))
+
+	    ;; A system variable -- only system help
+	    ((string-match 
+	      "\\`!\\([a-zA-Z0-9_]+\\)\\(\.\\([A-Za-z0-9_]+\\)\\)?" 
+	      this-word)
+	     (let* ((word  (match-string-no-properties 1 this-word))
+		    (entry (assq (idlwave-sintern-sysvar word)
+				 idlwave-system-variables-alist))
+		    (tag (match-string-no-properties 3 this-word))
+		    (tag-target (if tag
+				  (cdr
+				   (assq (idlwave-sintern-sysvartag tag)
+					 (cdr (assq 'tags entry))))))
+		    (link (nth 1 (assq 'link entry))))
+	       (if tag-target
+		   (setq link (idlwave-substitute-link-target link 
+							      tag-target)))
+	       (setq mod1 (list link))))
+			  
+	    ;; An executive command -- only system help
+	    ((string-match "^\\.[A-Z]+" this-word)
+	     (let* ((word  (match-string 0 this-word))
+		    (link  (cdr (assoc-ignore-case 
+				 this-word
+				 idlwave-executive-commands-alist))))
+	       (setq mod1 (list link))))
+	    
+	    ;; A class -- system OR in-text help (via class__define).
+	    ((and (eq cw 'class)
+		  (or (idlwave-in-quote)  ; e.g. obj_new
+		      (re-search-backward "\\<inherits[ \t]+[A-Za-z0-9_]*\\="
+					  (max (point-min) (- (point) 40)) t)))
+	     ;; Class completion inside string delimiters must be
+	     ;; the class inside OBJ_NEW.
+	     (let* ((entry  (assq
+			     (idlwave-sintern-class this-word)
+			     idlwave-system-class-info))
+		    (name   (concat (downcase this-word) "__define"))
+		    (link   (nth 1 (assq 'link entry))))
+	       (setq mod1 (list link name 'pro))))
+
+	    ;; A class structure tag (self.BLAH) -- only in-text help available
+	    (classtag
+	     (let ((tag (substring this-word (match-end 0)))
+		   class-with)
+	       (when (setq class-with 
+			   (idlwave-class-or-superclass-with-tag
+			    (nth 2 (idlwave-current-routine))
+			    tag))
+		 (if (assq (idlwave-sintern-class class-with) 
+			   idlwave-system-class-info)
+		     (error "No help available for system class tags"))
+		 (setq idlwave-help-do-class-struct-tag t)
+		 (setq mod1 (list nil 
+				  (concat class-with "__define")
+				  'pro
+				  nil ; no class.... it's a procedure!
+				  tag)))))
+
+	    ;; A regular structure tag -- only in text, and if
+	    ;; optional `complete-structtag' loaded.
+	    (structtag
+	     (let ((var (match-string 1 this-word))
+		   (tag (substring this-word (match-end 0))))
+	       ;; Check if we need to update the "current" structure
+	       (idlwave-prepare-structure-tag-completion var)
+	       (setq idlwave-help-do-struct-tag
+		     idlwave-structtag-struct-location
+		     mod1 (list nil nil nil nil tag))))
+	    
+	    ;; A routine keyword -- in text or system help
+	    ((and (memq cw '(function-keyword procedure-keyword))
+		  (stringp this-word)
+		  (string-match "\\S-" this-word)
+		  (not (string-match "!" this-word)))
+	     (cond ((or (= (char-before beg) ?/)
+			(save-excursion (goto-char end)
+					(looking-at "[ \t]*=")))
+		    ;; Certainly a keyword. Check for abbreviation etc.
+		    (setq keyword (idlwave-expand-keyword this-word module))
+		    (cond
+		     ((null keyword)
+		      (idlwave-help-diagnostics
+		       (format "%s does not accept `%s' kwd"
+			       (idlwave-make-full-name (nth 2 module)
+						       (car module))
+			       (upcase this-word))
+		       'ding))
+		     ((consp keyword)
+		      (idlwave-help-diagnostics
+		       (format "%d matches for kwd abbrev `%s'"
+			       (length keyword) this-word)
+		       'ding)
+		      ;; We continue anyway with the first match...
+		      (setq keyword (car keyword))))
+		    ;; Keyword, or just module
+		    (setq mod1 (append (list t) module (list keyword)))
+		    (setq mod2 (append (list t) module)))
+		   ((equal (char-after end) ?\()
+		    ;; A function - what-module will have caught this
+		    (setq mod1 (append (list t) module)))
+		   (t
+		    ;; undecided - try function, keyword, then enclosing mod.
+		    ;; Check for keyword abbreviations, but do not report
+		    ;; errors, because it might be something else.
+		    ;; FIXME: is this a good way to handle this?
+		    (setq keyword (idlwave-expand-keyword this-word module))
+		    (if (consp keyword) (setq keyword (car keyword)))
+		    (setq mod1 (append (list t) module (list keyword))
+			  mod2 (list t this-word 'fun nil)
+			  mod3 (append (list t) module)))))
+	    
+	    ;; Everything else
+	    (t
+	     (setq mod1 (append (list t) module))))
+      (if mod3
+	  (condition-case nil
+	      (apply 'idlwave-online-help mod1)
+	    (error (condition-case nil
+		       (apply 'idlwave-online-help mod2)
+		     (error (apply 'idlwave-online-help mod3)))))
+	(if mod2
+	    (condition-case nil
+		(apply 'idlwave-online-help mod1)
+	      (error (apply 'idlwave-online-help mod2)))
+	  (if mod1
+	      (apply 'idlwave-online-help mod1)
+	    (error "Don't know which item to show help for")))))))
+
+(defun idlwave-do-mouse-completion-help (ev)
+  "Display online help on an item in the *Completions* buffer.
+Needs additional info stored in global `idlwave-completion-help-info'."
+  (let* ((cw (selected-window))
+	 (info idlwave-completion-help-info) ; global passed in
+	 (what (nth 0 info))
+	 (name (nth 1 info))
+	 (type (nth 2 info))
+	 (class (nth 3 info))
+	 (need-class class)
+	 (kwd (nth 4 info))
+	 (sclasses (nth 5 info))
+	 word link)
+    (mouse-set-point ev)
+
+	  
+    ;; See if we can also find help somewhere, e.g. for multiple classes
+    (setq word (idlwave-this-word))
+    (if (string= word "")
+	(error "No help item selected"))
+    (setq link (get-text-property 0 'link word))
+    (select-window cw)
+    (cond 
+     ;; Routine name
+     ((memq what '(procedure function routine))
+      (setq name word)
+      (if (or (eq class t)
+	      (and (stringp class) sclasses))
+	  (let* ((classes (idlwave-all-method-classes
+			   (idlwave-sintern-method name)
+			   type)))
+	    (setq link t)		; No specific link valid yet
+	    (if sclasses
+		(setq classes (idlwave-members-only 
+			       classes (cons class sclasses))))
+	    (setq class (idlwave-popup-select ev classes 
+					      "Select Class" 'sort))))
+
+      ;; XXX is this necessary, given all-method-classes?
+      (if (stringp class)
+	  (setq class (idlwave-find-inherited-class
+		       (idlwave-sintern-routine-or-method name class)
+		       type (idlwave-sintern-class class)))))
+
+     ;; Keyword
+     ((eq what 'keyword)
+      (setq kwd word)
+      (if (or (eq class t)
+	      (and (stringp class) sclasses))
+	  (let ((classes  (idlwave-all-method-keyword-classes
+			   (idlwave-sintern-method name)
+			   (idlwave-sintern-keyword kwd)
+			   type)))
+	    (setq link t) ; Link can't be correct yet
+	    (if sclasses
+		(setq classes (idlwave-members-only 
+			       classes (cons class sclasses))))
+	    (setq class (idlwave-popup-select ev classes
+					      "Select Class" 'sort))
+	    ;; XXX is this necessary, given all-method-keyword-classes?
+	    (if (stringp class)
+		(setq class (idlwave-find-inherited-class
+			     (idlwave-sintern-routine-or-method name class)
+			     type (idlwave-sintern-class class)))))
+	(if (string= (downcase name) "obj_new")
+	    (setq class idlwave-current-obj_new-class
+		  name "Init"))))
+	  
+     ;; Class name
+     ((eq what 'class)
+      (setq class word
+	    word nil))
+     
+     ;; A special named function to call which sets some of our variables
+     ((and (symbolp what) 
+	   (fboundp what))
+      (funcall what 'set word))
+
+     (t (error "Cannot help with this item")))
+    (if (and need-class (not class) (not (and link (not (eq link t)))))
+	(error "Cannot help with this item"))
+    (idlwave-online-help link (or name word) type class kwd)))
+
+(defvar idlwave-highlight-help-links-in-completion)
+(defvar idlwave-completion-help-links)
+(defun idlwave-highlight-linked-completions ()
+  "Highlight all completions for which help is available and attach link.
+Those words in `idlwave-completion-help-links' have links.  The
+`idlwave-help-link-face' face is used for this."
+  (if idlwave-highlight-help-links-in-completion      
+      (with-current-buffer (get-buffer "*Completions*")
+	(save-excursion
+	  (let* ((case-fold-search t)
+		 (props (list 'face 'idlwave-help-link-face))
+		 (info idlwave-completion-help-info) ; global passed in
+		 (what (nth 0 info))  ; what was completed, or a func
+		 (class (nth 3 info)) ; any class
+		 word beg end doit)
+	    (goto-char (point-min))
+	    (re-search-forward "possible completions are:" nil t)
+	    (while (re-search-forward "\\s-\\([A-Za-z0-9_]+\\)\\(\\s-\\|\\'\\)"
+				      nil t)
+	      (setq beg (match-beginning 1) end (match-end 1)
+		    word (match-string 1) doit nil)
+	      ;; Call special completion function test
+	      (if (and (symbolp what) 
+		       (fboundp what))
+		  (setq doit (funcall what 'test word))
+		;; Look for special link property passed in help-links
+		(if idlwave-completion-help-links
+		    (setq doit (assoc-ignore-case 
+				word idlwave-completion-help-links))))
+	      (when doit
+		(if (consp doit)
+		    (setq props (append props `(link ,(cdr doit)))))
+		(let ((buffer-read-only nil))
+		  (add-text-properties beg end props)))
+	      (goto-char end)))))))
+
+;; Arrange for this function to be called after completion
+(add-hook 'idlwave-completion-setup-hook
+	  'idlwave-highlight-linked-completions)
+
+(defvar idlwave-help-return-frame nil
+  "The frame to return to from the help frame.")
+
+(defun idlwave-help-quit ()
+  "Exit IDLWAVE Help buffer.  Kill the dedicated frame if any."
+  (interactive)
+  (cond ((and idlwave-help-use-dedicated-frame
+	      (eq (selected-frame) idlwave-help-frame))
+	 (if (and idlwave-experimental
+		  (frame-live-p idlwave-help-return-frame))
+	     ;; Try to select the return frame.
+	     ;; This can crash on slow network connections, obviously when
+	     ;; we kill the help frame before the return-frame is selected.
+	     ;; To protect the workings, we wait for up to one second 
+	     ;; and check if the return-frame *is* now selected.
+	     ;; This is marked "eperimental" since we are not sure when its OK.
+	     (let ((maxtime 1.0) (time 0.) (step 0.1))
+	       (select-frame idlwave-help-return-frame)
+	       (while (and (sit-for step)
+			   (not (eq (selected-frame) 
+				    idlwave-help-return-frame))
+			   (< (setq time (+ time step)) maxtime)))))
+	 (delete-frame idlwave-help-frame))
+	((window-configuration-p idlwave-help-window-configuration)
+	 (set-window-configuration idlwave-help-window-configuration)
+	 (select-window (previous-window)))
+	(t (kill-buffer (idlwave-help-get-help-buffer)))))
+
+
+(defvar default-toolbar-visible-p)
+
+(defun idlwave-help-display-help-window (&optional pos-or-func)
+  "Display the help window.  
+Move window start to POS-OR-FUNC, if passed as a position, or call it
+if passed as a function.  See `idlwave-help-use-dedicated-frame'."
+  (let ((cw (selected-window))
+	(buf (idlwave-help-get-help-buffer)))
+    (if (and window-system idlwave-help-use-dedicated-frame)
+	(progn
+	  (idlwave-help-show-help-frame)
+	  (switch-to-buffer buf))
+      ;; Do it in this frame and save the window configuration
+      (if (not (get-buffer-window buf nil))
+	  (setq idlwave-help-window-configuration 
+		(current-window-configuration)))
+      (display-buffer buf nil (selected-frame))
+      (select-window (get-buffer-window buf)))
+    (raise-frame)
+    (if pos-or-func 
+	(if (functionp pos-or-func) 
+	    (funcall pos-or-func)
+	  (goto-char pos-or-func)
+	  (recenter 0)))
+    (select-window cw)))
+
+(defun idlwave-help-select-help-frame ()
+  "Select the help frame."
+  (if (and (frame-live-p idlwave-help-frame)
+	   (not (eq (selected-frame) idlwave-help-frame)))
+      (progn
+	(setq idlwave-help-return-frame (selected-frame))
+	(select-frame idlwave-help-frame))))
+
+(defun idlwave-help-return-to-calling-frame ()
+  "Select the frame from which the help frame was selected."
+  (interactive)
+  (if (and (frame-live-p idlwave-help-return-frame)
+	   (not (eq (selected-frame) idlwave-help-return-frame)))
+      (select-frame idlwave-help-return-frame)))
+
+(defun idlwave-online-help (link &optional name type class keyword)
+  "Display HTML or other special help on a certain topic.  
+Either loads an HTML link, if LINK is non-nil, or gets special-help on
+the optional arguments, if any special help is defined.  If LINK is
+`t', first look up the optional arguments in the routine info list to
+see if a link is set for it.  Try extra help functions if necessary."
+  ;; Lookup link
+  (if (eq link t) 
+      (let ((entry (idlwave-best-rinfo-assoc name type class 
+					     (idlwave-routines))))
+	(cond
+	 ;; Try keyword link
+	 ((and keyword 
+	       (setq link (cdr (idlwave-entry-find-keyword entry keyword)))))
+	 ;; Default, regular entry link
+	 (t (setq link (idlwave-entry-has-help entry))))))
+
+  (cond
+   ;; An explicit link
+   ((stringp link) 
+    (idlwave-help-html-link link))
+   
+   ;; Any extra help
+   (idlwave-extra-help-function
+    (idlwave-help-get-special-help name type class keyword))
+   
+   ;; Nothing worked
+   (t (idlwave-help-error name type class keyword))))
+
+
+(defun idlwave-help-get-special-help (name type class keyword)
+  "Call the function given by `idlwave-extra-help-function'."
+  (let* ((cw (selected-window))
+	 (help-pos (save-excursion
+		     (set-buffer (idlwave-help-get-help-buffer))
+		     (let ((buffer-read-only nil))
+		       (funcall idlwave-extra-help-function 
+				name type class keyword)))))
+    (if help-pos
+	(idlwave-help-display-help-window help-pos)
+      (idlwave-help-error name type class keyword))
+    (select-window cw)))
+
+(defun idlwave-help-html-link (link)
+  "Get html help on a given LINK."
+  (let ((browse-url-browser-function idlwave-help-browser-function)
+	(help-loc (idlwave-html-help-location))
+	(browse-url-generic-program idlwave-help-browser-generic-program)
+	;(browse-url-generic-args idlwave-help-browser-generic-args)
+	full-link)
+    
+    (if (and (memq system-type '(ms-dos windows-nt))
+	     idlwave-help-use-hh)
+	(progn
+	  (setq browse-url-browser-function 'browse-url-generic
+		full-link (concat (expand-file-name "idl.chm" help-loc)
+				  "::/"
+				  link))
+	  (if (memq 'keyhh idlwave-help-use-hh)
+	      (setq browse-url-generic-program "KEYHH"
+		    browse-url-generic-args '("-IDLWAVE"))
+	    (setq browse-url-generic-program "HH")))
+      ;; Just a regular file name (+ anchor name)
+      (unless (and (stringp help-loc)
+		   (file-directory-p help-loc))
+	(error 
+	 "Invalid help location; customize `idlwave-html-help-location'."))
+      (setq full-link (concat 
+		       "file://"
+		       (expand-file-name 
+			link 
+			(expand-file-name "idl_html_help" help-loc)))))
+
+    ;; Check for a local browser
+    (if (or idlwave-help-browser-is-local
+	    (string-match "w3" (symbol-name idlwave-help-browser-function)))
+	(idlwave-help-display-help-window '(lambda () (browse-url full-link)))
+      (browse-url full-link))))
+
+;; A special help routine for source-level syntax help in files.
+(defvar idlwave-help-def-pos)
+(defvar idlwave-help-args)
+(defvar idlwave-help-in-header)
+(defvar idlwave-help-fontify-source-code)
+(defvar idlwave-help-source-try-header)
+(defun idlwave-help-with-source (name type class keyword)
+  "Provide help for routines not documented in the IDL manuals.  Works
+by loading the routine source file into the help buffer.  Depending on
+the value of `idlwave-help-source-try-header', it attempts to show the
+routine definition or the header description.  If
+`idlwave-help-do-class-struct-tag' is non-nil, keyword is a tag to
+show help on from the class definition structure.  If
+`idlwave-help-do-struct-tag' is non-nil, show help from the matching
+structure tag definition.
+
+This function can be used as `idlwave-extra-help-function'."
+  (let* ((class-struct-tag idlwave-help-do-class-struct-tag)
+	 (struct-tag idlwave-help-do-struct-tag)
+	 (case-fold-search t)
+	 (class-only (and (stringp class) (not (stringp name))))
+	 file header-pos def-pos in-buf)
+    (if class-only   ;Help with class?  Using "Init" as source.
+	(setq name "Init"
+	      type 'fun))
+    (if (not struct-tag) 
+	(setq file
+	      (idlwave-routine-source-file
+	       (nth 3 (idlwave-best-rinfo-assoc
+		       name (or type t) class (idlwave-routines))))))
+    (setq idlwave-help-def-pos nil
+	  idlwave-help-args (list name type class keyword)
+	  idlwave-help-in-header nil
+	  idlwave-help-do-struct-tag nil
+	  idlwave-help-do-class-struct-tag nil)
+    (if (or struct-tag (stringp file))
+	(progn
+	  (setq in-buf ; structure-tag completion is always in current buffer
+		(if struct-tag 
+		    idlwave-current-tags-buffer
+		  (idlwave-get-buffer-visiting file)))
+	  ;; see if file is in a visited buffer, insert those contents
+	  (if in-buf
+	      (progn
+		(setq file (buffer-file-name in-buf))
+		(erase-buffer)
+		(insert-buffer in-buf))
+	    (if (file-exists-p file) ;; otherwise just load the file
+		(progn
+		  (erase-buffer)
+		  (insert-file-contents file nil nil nil 'replace))
+	      (idlwave-help-error name type class keyword)))
+	  (if (and idlwave-help-fontify-source-code (not in-buf))
+	      (idlwave-help-fontify)))
+      (idlwave-help-error name type class keyword))
+    (setq idlwave-help-mode-line-indicator file)
+
+    ;; Try to find a good place to display
+    (setq def-pos
+	  ;; Find the class structure tag if that's what we're after
+	  (cond 
+	   ;; Class structure tags: find the class definition
+	   (class-struct-tag
+	    (save-excursion 
+	      (setq class
+		    (if (string-match "[a-zA-Z0-9]\\(__\\)" name) 
+			(substring name 0 (match-beginning 1))
+		      idlwave-current-tags-class))
+	      (and
+	       (idlwave-find-class-definition class)
+	       (idlwave-find-struct-tag keyword))))
+	   
+	   ;; Generic structure tags: the structure definition
+	   ;; location within the file has been recorded in
+	   ;; `struct-tag'
+	   (struct-tag
+	    (save-excursion
+	      (and
+	       (integerp struct-tag)
+	       (goto-char struct-tag)
+	       (idlwave-find-struct-tag keyword))))
+	   
+	   ;; Just find the routine definition
+	   (t
+	    (if class-only (point-min)
+	      (idlwave-help-find-routine-definition name type class keyword))))
+	  idlwave-help-def-pos def-pos)
+
+    (if (and idlwave-help-source-try-header 
+	     (not (or struct-tag class-struct-tag)))
+	;; Check if we can find the header
+	(save-excursion
+	  (goto-char (or def-pos (point-max)))
+	  (setq header-pos (idlwave-help-find-in-doc-header
+			    name type class keyword 'exact)
+		idlwave-help-in-header header-pos)))
+
+    (if (or header-pos def-pos)
+	(progn 
+	  (if (boundp 'idlwave-help-min-frame-width)
+	      (setq idlwave-help-min-frame-width 80))
+	  (goto-char (or header-pos def-pos)))
+      (idlwave-help-error name type class keyword))
+
+    (point)))
+
+
+(defun idlwave-help-find-routine-definition (name type class keyword)
+  "Find the definition of routine CLASS::NAME in current buffer.
+KEYWORD is ignored. Returns the point of match if successful, nil otherwise."
+  (save-excursion
+    (goto-char (point-max))
+    (if (re-search-backward 
+	 (concat "^[ \t]*"
+		 (if (eq type 'pro) "pro"
+		   (if (eq type 'fun) "function"
+		     "\\(pro\\|function\\)"))
+		 "[ \t]+"
+		 (regexp-quote (downcase (idlwave-make-full-name class name)))
+		 "[, \t\r\n]")
+	 nil t)
+	(match-beginning 0)
+      nil)))
+
+(defvar idlwave-doclib-start)
+(defvar idlwave-doclib-end)
+(defun idlwave-help-find-in-doc-header (name type class keyword
+					     &optional exact)
+  "Find the requested help in the doc-header above point.
+
+First checks if there is a doc-lib header which describes the correct
+routine.  Then tries to find the KEYWORDS section and the KEYWORD, if
+given.  Returns the point which should be window start of the help
+window.  If EXACT is non-nil, the full help position must be found -
+down to the keyword requested.  This setting is for context help, if
+the exact spot is needed.
+
+If EXACT is nil, the position of the header is returned if it
+describes the correct routine - even if the keyword description cannot
+be found.  TYPE is ignored.
+
+This function expects a more or less standard routine header.  In
+particlar it looks for the `NAME:' tag, either with a colon, or alone
+on a line.  Then `NAME:' must be followed by the routine name on the
+same or the next line.  When KEYWORD is non-nil, looks first for a
+`KEYWORDS' section.  It is amazing how inconsisten this is through
+some IDL libraries I have seen.  We settle for a line containing an
+upper case \"KEYWORD\" string.  If this line is not fould we search
+for the keyword anyway to increase the hit-rate
+
+When one of these sections exists we check for a line starting with any of
+
+  /KEYWORD  KEYWORD-  KEYWORD=  KEYWORD
+
+with spaces allowed between the keyword and the following dash or equal sign.
+If there is a match, we assume it is the keyword description."
+  (let* ((case-fold-search t)
+	 (rname (if (stringp class)
+		    (concat 
+		     "\\("
+		     ;; Traditional name or class::name
+		     "\\("
+		     "\\(" (regexp-quote (downcase class)) "::\\)?"
+		     (regexp-quote (downcase name))
+		     "\\>\\)"
+		     (concat 
+		      "\\|"
+		      ;; class__define or just class
+		      (regexp-quote (downcase class)) "\\(__define\\)?")
+		     "\\)")
+		  (regexp-quote (downcase name))))
+	 
+	 ;; NAME tag plus the routine name.  The new version is from JD.
+	 (name-re (concat 
+		   "\\(^;+\\*?[ \t]*"
+		   idlwave-help-doclib-name
+		   "\\([ \t]*:\\|[ \t]*$\\)[ \t]*\\(\n;+[ \t]*\\)*"
+		   rname
+		   "\\|"
+		   "^;+[ \t]*"
+		   rname
+		   ":[ \t]*$\\)"))
+
+	 ;; Header start plus name
+	 (header-re (concat "\\(" idlwave-doclib-start "\\).*\n"
+			    "\\(^;+.*\n\\)*"
+			    "\\(" name-re "\\)"))
+	 ;; A keywords section
+	 (kwds-re (concat		                    ; forgiving
+		   "^;+\\*?[ \t]*"
+		   "\\([-A-Z_ ]*"
+		   idlwave-help-doclib-keyword
+		   "[-A-Z_ ]*\\)"
+		   "\\(:\\|[ \t]*\n\\)"))
+
+	 ;; The individual keyword description line.
+	 (kwd-re (if keyword                                ; hard (well...)
+		     (concat
+		      "^;+[ \t]+"
+		      "\\(/" (regexp-quote (upcase keyword))
+		      "\\|"  (regexp-quote (upcase keyword)) "[ \t]*[-=:\n]"
+		      "\\)")))
+	 (kwd-re2 (if keyword                               ; forgiving
+		      (concat
+		       "^;+[ \t]+"
+		       (regexp-quote (upcase keyword))
+		      "\\>")))
+	 dstart dend name-pos kwds-pos kwd-pos)
+    (catch 'exit 
+      (save-excursion
+	(goto-char (point-min))
+	(while (and (setq dstart (re-search-forward idlwave-doclib-start nil t))
+		    (setq dend (re-search-forward idlwave-doclib-end nil t)))
+	  ;; found a routine header
+	  (goto-char dstart)
+	  (if (setq name-pos (re-search-forward name-re dend t))
+	      (progn 
+		(if keyword
+		    ;; We do need a keyword
+		    (progn
+		      ;; Try to find a keyword section, but don't force it.
+		      (goto-char name-pos)
+		      (if (let ((case-fold-search nil))
+			    (re-search-forward kwds-re dend t))
+			  (setq kwds-pos (match-beginning 0)))
+		      ;; Find the keyword description
+		      (if (or (let ((case-fold-search nil))
+				(re-search-forward kwd-re dend t))
+			      (re-search-forward kwd-re dend t)
+			      (let ((case-fold-search nil))
+				(re-search-forward kwd-re2 dend t))
+			      (re-search-forward kwd-re2 dend t))
+			  (setq kwd-pos (match-beginning 0))
+			(if exact
+			    (progn
+			      (idlwave-help-diagnostics
+			       (format "Could not find description of kwd %s"
+				       (upcase keyword)))
+			      (throw 'exit nil))))))
+		;; Return the best position we got
+		(throw 'exit (or kwd-pos kwds-pos name-pos dstart)))
+	    (goto-char dend))))
+      (idlwave-help-diagnostics "Could not find doclib header")
+      (throw 'exit nil))))
+
+(defun idlwave-help-diagnostics (string &optional ding)
+  "Add a diagnostics string to the list.
+When DING is non-nil, ring the bell as well."
+  (if (boundp 'idlwave-help-diagnostics)
+      (progn
+	(setq idlwave-help-diagnostics
+	      (cons string idlwave-help-diagnostics))
+	(if ding (ding)))))
+
+(defun idlwave-help-toggle-header-top-and-def (arg)
+  (interactive "P")
+  (let (pos)
+    (if idlwave-help-in-header
+	;; Header was the last thing displayed
+	(progn
+	  (setq idlwave-help-in-header nil)
+	  (setq pos idlwave-help-def-pos))
+      ;; Try to display header
+      (setq pos (idlwave-help-find-in-doc-header
+		 (nth 0 idlwave-help-args)
+		 (nth 1 idlwave-help-args)
+		 (nth 2 idlwave-help-args)
+		 nil))
+      (if pos
+	  (setq idlwave-help-in-header t)
+	(error "Cannot find doclib header for routine %s"
+	       (idlwave-make-full-name (nth 2 idlwave-help-args)
+				       (nth 0 idlwave-help-args)))))
+    (if pos
+	(progn
+	  (goto-char pos)
+	  (recenter 0)))))
+
+(defun idlwave-help-find-first-header (arg)
+  (interactive "P")
+  (let (pos)
+    (save-excursion
+      (goto-char (point-min))
+      (if (re-search-forward idlwave-doclib-start nil t)
+	  (setq pos (match-beginning 0))))
+    (if pos
+	(progn
+	  (goto-char pos)
+	  (recenter 0))
+      (error "No DocLib Header in current file"))))
+
+(defun idlwave-help-find-header (arg)
+  "Jump to the DocLib Header."
+  (interactive "P")
+  (if arg
+      (idlwave-help-find-first-header nil)
+    (setq idlwave-help-in-header nil)
+    (idlwave-help-toggle-header-match-and-def arg 'top)))
+  
+(defun idlwave-help-toggle-header-match-and-def (arg &optional top)
+  (interactive "P")
+  (let ((args idlwave-help-args)
+	pos)
+    (if idlwave-help-in-header
+	;; Header was the last thing displayed
+	(progn
+	  (setq idlwave-help-in-header nil)
+	  (setq pos idlwave-help-def-pos))
+      ;; Try to display header
+      (setq pos (apply 'idlwave-help-find-in-doc-header
+		       (if top 
+			   (list (car args) (nth 1 args) (nth 2 args) nil)
+			 args)))
+      (if pos
+	  (setq idlwave-help-in-header t)
+	(error "Cannot find doclib header for routine %s"
+	       (idlwave-make-full-name (nth 2 idlwave-help-args)
+				       (nth 0 idlwave-help-args)))))
+    (if pos
+	(progn
+	  (goto-char pos)
+	  (recenter 0)))))
+
+(defvar font-lock-verbose)
+(defvar idlwave-mode-syntax-table)
+(defvar idlwave-font-lock-defaults)
+(defun idlwave-help-fontify ()
+  "Fontify the Help buffer as source code.
+Useful when source code is displayed as help.  See the option
+`idlwave-help-fontify-source-code'."
+  (interactive)
+  (if (featurep 'font-lock)
+      (let ((major-mode 'idlwave-mode)
+	    (font-lock-verbose
+	     (if (interactive-p) font-lock-verbose nil))
+	    (syntax-table (syntax-table)))
+	(unwind-protect
+	    (progn
+	      (set-syntax-table idlwave-mode-syntax-table)
+	      (set (make-local-variable 'font-lock-defaults)
+		   idlwave-font-lock-defaults)
+	      (font-lock-fontify-buffer))
+	  (set-syntax-table syntax-table)))))
+
+      
+(defun idlwave-help-error (name type class keyword)
+  (error "Can't find help on %s%s %s"
+	 (or (and (or class name) (idlwave-make-full-name class name))
+	     "<unknown>")
+	 (if keyword (format ", keyword %s" (upcase keyword)) "")
+	 (if idlwave-html-help-location
+	     ""
+	   "(help location unknown)")))
+
+(defun idlwave-help-show-help-frame ()
+  "Show the help frame, creating it if necessary"
+  ;; Use a special frame for this
+  (unless (frame-live-p idlwave-help-frame)
+    (setq idlwave-help-frame
+	  (make-frame idlwave-help-frame-parameters))
+    ;; Strip menubar (?) and toolbar from the Help frame.
+    (if (fboundp 'set-specifier)
+	(progn
+	  ;; XEmacs
+	  (let ((sval (cons idlwave-help-frame nil)))
+	    ;; (set-specifier menubar-visible-p sval)
+	    (set-specifier default-toolbar-visible-p sval)))
+      ;; Emacs
+      (modify-frame-parameters idlwave-help-frame
+			       '(;;(menu-bar-lines . 0)
+				 (tool-bar-lines . 0)))))
+  (select-frame idlwave-help-frame))
+
+(defun idlwave-help-get-help-buffer ()
+  "Return the IDLWAVE Help buffer.  Make it first if necessary."
+  (let ((buf (get-buffer "*IDLWAVE Help*")))
+    (if buf
+	nil
+      (setq buf (get-buffer-create "*IDLWAVE Help*"))
+      (save-excursion
+	(set-buffer buf)
+	(idlwave-help-mode)))
+    buf))
+
+(defun idlwave-grep (regexp list)
+  (let (rtn)
+    (while list
+      (if (string-match regexp (car list))
+	  (setq rtn (cons (car list) rtn)))
+      (setq list (cdr list)))
+    (nreverse rtn)))
+
+(defun idlwave-entry-has-help (entry)
+  (and entry (car (nth 5 entry))))
+
+(defun idlwave-has-help (name type class)
+  "Does this have help associated with it?"
+  (let ((entry (idlwave-best-rinfo-assoc name type class (idlwave-routines))))
+    (idlwave-entry-has-help entry)))
+
+(provide 'idlw-help)
+(provide 'idlwave-help)
+
+;;; idlw-help.el ends here