Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: master
Fetching contributors…

Cannot retrieve contributors at this time

788 lines (682 sloc) 25.803 kB
;;; javadoc-help.el --- Javadoc-Help. Look up Java class on online javadocs in browser.
;;
;; Copyright (C) 2008 William W. Wong
;;
;; Author: William W. Wong <williamw520(AT)yahoo(DOT)com>
;; Created: February, 2008
;; Version: 1.0
;; Keywords: javadoc, help, lookup, java
;; This file is not part of GNU Emacs.
;;; License
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License version 2 as
;; published by the Free Software Foundation.
;;
;; This program 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, 675 Mass Ave, Cambridge, MA 02139, USA.
;;
;;; Commentary:
;;
;; Javadoc-Help is an add-on module for Emacs that let you search a class
;; through multiple online and local javadocs quickly, and view the found
;; class documentation in the system web browser.
;;
;; Modified by Phil Hagelberg to follow Emacs conventions a little
;; more closely. Removed saving/restoring settings from file; jmenu
;; functions. Use elisp code to set variables instead.
;;; Overview:
;;
;; - Look up the javadoc of a Java class.
;; - Search through multiple javadocs.
;; - Search through online or local javadoc.
;; - Search can be the class name, package name, partial name, or regex.
;; - Support multiple search results.
;; - Display the doc for the class, the package, or the main page.
;;
;;; Installation:
;;
;; Copy the javadoc-help.el file to your load-path directory.
;; It's usually at ~/elisp/. It's set in your .emacs like this:
;; (setq load-path (append (list (expand-file-name "~/elisp")) load-path))
;;
;; Next add the following to your .emacs startup file.
;; (require 'javadoc-help)
;;
;; or add the autoloads for the public command functions.
;; (autoload 'javadoc-lookup "javadoc-help" "Look up Java class in Javadoc." t)
;;; Configuration:
;;
;; Assign the commands to some keys in your .emacs file.
;;
;; Example:
;;
;; (global-set-key (kbd "C-h j") 'javadoc-lookup)
;;
;; Javadoc-help uses browse-url to launch the system web browser. Make sure
;; it's working for your platform. Try it out with, M-x browse-url. Usually
;; browse-url defaults to the OS default browser. Some the OS default browser
;; might not be set up. Use 'M-x customize-option' browse-url-browser-function
;; to pick a specific browser, (like setting Firefox as the browser to use).
;;
;;; Usage:
;;
;; Set up the javadocs by going to the Javadoc-help menu. You can then add
;; a url-based javadoc or a local file-based javadoc using the 'u' or 'f'
;; command key. The javadoc urls should be pointing to the main index
;; directory of the javadoc, which containing the allclasses-frame.html file.
;; For example, http://commons.apache.org/lang/api-release/, /opt/jsee/docs/api/, or
;; c:/jdk/docs/api/. The entered javadocs are saved persistently.
;;
;; After adding the javadoc url, try the 'o' command key to open the main
;; index page of the javadoc in the browser.
;;
;; To look up the javadoc for a class, invoke the javadoc-lookup (F1) command.
;; Type in the class name to look up. The name near the cursor in the current
;; buffer is automatically used as the initial input. The search term can be
;; a partial class name, a package name, or it can be a regex. For example,
;; Connection
;; String
;; .*lang.*String
;; java.io
;;
;; The lookup might produce multiple matches. The *Javadoc-Search-Result*
;; window offers a number of commands to view the class, the package, or the
;; main javadoc page.
;;
;; The search term history is accessable via the up/down arrows during input.
;;
;; If you prefer setting up the javadoc urls in your .emacs file, you can call
;; javadoc-set-predefined-urls in .emacs to set up the pre-defined javadoc urls.
;; e.g.
;; (javadoc-set-predefined-urls '("c:/jdk/docs/api" "/opt/jsee/docs/api"))
;;
;;; Acknowledgements:
;;
;;
;;; History:
;;
;; 2008/02/29 William Wong
;; Daily usage and general testing done.
;; Version 1.0
;;
;; 2008/02/20 William Wong
;; Major features completed.
;;
;; 2008/02/09 William Wong
;; Start project.
;; Version 0.0
;;
;;;
;; Todo:
;;
;;
;;
;;; Code:
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Public section
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; User Configuration Variables
;;
;; Customize the options by:
;; 'M-x customize-option' javadoc-help-setting-file
;; 'M-x customize-option' javadoc-help-cache-dir
;;
(defgroup javadoc-help nil
"Look up Java class on online Javadocs in web browser."
:link '(emacs-library-link :tag "Source Lisp File" "javadoc-help.el")
:group 'editing
:prefix "javadoc-")
(defcustom javadoc-help-setting-file (expand-file-name "~/.javadoc-help")
"*Filename to store Javadoc-Help's settings."
:type 'string
:group 'javadoc-help)
(defcustom javadoc-help-cache-dir (expand-file-name "~/.javadoc-cache")
"*Directory name to cache the downloaded Javadoc files."
:type 'string
:group 'javadoc-help)
(defcustom javadoc-hook nil
"Hook to run when javadoc buffers are opened.")
;;; User callable functions
;;;###autoload
(defun javadoc-lookup ()
"Look up Java class in Javadoc."
(interactive)
(let* ((initial-search-term (thing-at-point 'java-identifier))
(search-term (jdh-get-search-input initial-search-term))
match-list
single-result-url)
(when (and search-term
(> (length search-term) 0))
(setq match-list (jdh-search-in-files search-term))
(if (null match-list)
(message (format "%s not found" search-term))
; Present the multi-result to user, or launch single-result-url in browser.
(setq single-result-url (jdh-select-result match-list))
(when single-result-url
(message (format "Single matched item. Launching web browser on %s" single-result-url))
(browse-url single-result-url)))
)
)
)
(defun javadoc-set-predefined-urls (url-list)
"Set the list of the pre-defined urls."
(if (not (listp url-list))
(message "Predefined url-list is not passed in as a list.")
(setq *jdh-predefined-urls* url-list))
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Private section
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Program global variables:
(defvar *jdh-javadocs* ()
"List of javadoc records. The list is (javadoc1 javadoc2 ...) where each javadoc is (url attr1 attr2 ...)"
)
(defvar *jdh-predefined-urls* ()
"List of javadoc urls."
)
(defvar *jdh-url-input-history* ()
"List of URL input history."
)
(defvar *jdh-dir-input-history* nil
"List of file input history."
)
(defvar *jdh-search-input-history* ()
"List of URL input history."
)
(defvar *jdh-matched-search* ()
"The list of matched search term."
)
;;; Constants
(defconst jdh--file-allclasses "allclasses-frame.html")
(defconst jdh--jmenu-buffer "*Javadoc-Help*")
(defconst jdh--jmenu-mode-name "*Javadoc-Help*")
(defconst jdh--smenu-buffer "*Javadoc-Search-Result*")
(defconst jdh--smenu-mode-name "*Javadoc-Search-Result*")
(defconst jdh--temp-buffer "*javadoc-help-temp-buffer*")
(defconst jdh--file-magic "WJDH")
(defconst jdh--file-version 1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Javadoc url record functions
(defun jdh-javadoc-new (url refreshed enabled predefined)
"Construct a Javadoc url record, saving its javadoc-url in the list."
; record [url refreshed enabled predefined reserved reserved reserved reserved reserved reserved]
(list url refreshed enabled predefined nil nil nil nil nil nil)
)
(defun jdh-javadoc-url (javadoc)
"Return the url part of a javadoc record."
(car javadoc)
)
(defun jdh-javadoc-set-url (javadoc url)
"Set the url of a javadoc"
(setcar javadoc url)
)
(defun jdh-javadoc-refreshed (javadoc)
"Return the url part of a javadoc record."
(car (nthcdr 1 javadoc))
)
(defun jdh-javadoc-set-refreshed (javadoc refreshed)
"Set the refreshed field of a javadoc"
(if (> (length javadoc) 1)
(setcar (nthcdr 1 javadoc) refreshed)
(setcdr javadoc (cons refreshed nil)))
)
(defun jdh-javadoc-enabled (javadoc)
"Return the url part of a javadoc record."
(car (nthcdr 2 javadoc))
)
(defun jdh-javadoc-set-enabled (javadoc enabled)
"Set the enabled field of a javadoc"
(if (> (length javadoc) 2)
(setcar (nthcdr 2 javadoc) enabled)
(setcdr (nthcdr 1 javadoc) (cons enabled nil)))
)
(defun jdh-javadoc-predefined (javadoc)
"Return the url part of a javadoc record."
(car (nthcdr 3 javadoc))
)
(defun jdh-javadoc-set-predefined (javadoc predefined)
"Set the predefined field of a javadoc"
(if (> (length javadoc) 3)
(setcar (nthcdr 3 javadoc) predefined)
(setcdr (nthcdr 2 javadoc) (cons predefined nil)))
)
(defun jdh-javadocs-add (javadoc)
"Add a javadoc to the javadoc list"
;; Remove existing duplicate javadoc.
(let* ((url (jdh-javadoc-url javadoc))
(existing-index (jdh-javadocs-find-by-url url)))
(if existing-index
(jdh-javadocs-remove-at existing-index))
)
(setq *jdh-javadocs* (append *jdh-javadocs* (list javadoc)))
)
(defun jdh-javadocs-get (index)
"Get the javadoc by index from the javadoc list."
(if index
(nth index *jdh-javadocs*)
nil)
)
(defun jdh-javadocs-find-by-url (url)
"Find a javadoc index by url from the javadoc list."
(let ((index 0)
(found-index nil))
(mapc
(lambda (url-record)
(if (and (null found-index)
(equal url (jdh-javadoc-url url-record)))
(setq found-index index))
(setq index (1+ index)))
*jdh-javadocs*)
found-index)
)
(defun jdh-javadocs-remove (javadoc)
"Remove a javadoc from the javadoc list."
(setq *jdh-javadocs* (remove javadoc *jdh-javadocs*))
(jdh-javadocs-save)
)
(defun jdh-javadocs-remove-at (index)
"Remove a javadoc by index from the javadoc list."
(let ((javadoc (jdh-javadocs-get index)))
(setq *jdh-javadocs* (remove javadoc *jdh-javadocs*)))
(jdh-javadocs-save)
)
(defun jdh-javadoc-to-str (javadoc)
"Convert a javadoc to a string."
(let ((url (jdh-javadoc-url javadoc))
(attrs ()))
(if (not (jdh-javadoc-enabled javadoc))
(setq attrs (push "disabled" attrs)))
(if (not (jdh-javadoc-refreshed javadoc))
(setq attrs (push "refresh needed" attrs)))
(if (jdh-javadoc-predefined javadoc)
(setq attrs (push "predefined" attrs)))
(if attrs
(format "%-60s [%s]" url (mapconcat 'identity attrs ", "))
url)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Search helper functions
(defun jdh-get-search-input (initial-search-term)
"Get the search term input from user."
(interactive)
(let* ((input-str (read-from-minibuffer
"Search Name: "
initial-search-term
nil
nil
'*jdh-search-input-history*
initial-search-term)))
(string-trim input-str)
)
)
(defun jdh-search-in-files (search-term)
"Search the search term in the javadoc files."
(let ((allclasses-files (jdh-get-allclasses-files))
(match-list nil))
(if (and search-term
(> (length search-term) 0))
(mapc (lambda (file-record)
(when file-record
(let* ((url-file-base (car file-record))
(pathname (cdr file-record))
(found-list (jdh-search-file search-term url-file-base pathname))
)
(setq match-list (append match-list found-list))
)))
allclasses-files
))
match-list
)
)
(defun jdh-search-file (search-term url-file-base file-path)
"Search the search term in a javadoc file."
(save-window-excursion
(set-buffer (get-buffer-create jdh--temp-buffer))
(let ((match-list nil)
(search-re-expr (concat "<A HREF=.*" search-term ".*\\.html"))
found-filename)
(insert-file-contents file-path nil nil nil t) ; load file
(goto-char (point-min))
; Search for all occurrences of the search-term
(while (re-search-forward search-re-expr (point-max) t)
(progn
(beginning-of-line)
; Extract the found filename between the quotes
(re-search-forward "<A HREF=\"\\([^\"]*\\)\"")
(setq found-filename (buffer-substring (match-beginning 1) (match-end 1)))
(push (cons url-file-base found-filename) match-list)
))
(reverse match-list)))
)
(defun jdh-get-allclasses-files ()
"Convert the list in *jdh-javadocs* to a list of allclasses files."
(mapcar (lambda (javadoc)
(let* ((url-file-base (jdh-javadoc-url javadoc))
(allclasses-file (jdh-get-allclasses-local-file url-file-base)))
(if (and (jdh-javadoc-enabled javadoc)
(file-readable-p allclasses-file))
(cons url-file-base allclasses-file)
nil))
)
*jdh-javadocs*)
)
(defun jdh-get-allclasses-url-file (url-file-base)
"Convert the url-file-base to an allclasses url."
(concat-path url-file-base jdh--file-allclasses)
)
(defun jdh-get-allclasses-local-file (url-file-base)
"Convert the url-file-base to an allclasses file."
(let ((allclasses-file (jdh-get-allclasses-url-file url-file-base)))
(if (jdh-http-p url-file-base)
(concat javadoc-help-cache-dir "/" (jdh-convert-url-to-file allclasses-file))
allclasses-file))
)
(defun jdh-convert-url-to-file (url)
"Convert a url to a local filename, with escape char."
(let* ((url0 (replace-regexp-in-string "/" "-" url))
(url1 (replace-regexp-in-string "[^[:alnum:]\\._\\-]" "_" url0))
(url2 (md5 url))
(len (min (length url1) 24)))
(concat (substring url1 0 len) url2))
)
(defun jdh-select-result (match-list)
"Select single result item automatically or present the result list to the user."
(if (= (length match-list) 1)
(jdh-get-match-url (car match-list))
(jdh-present-matches match-list)
nil)
)
(defun jdh-present-matches (match-list)
"Presetnt the result of the class search to let the user pick one to browse."
(interactive)
(setq *jdh-matched-search* match-list)
(switch-to-buffer-other-window (get-buffer-create jdh--smenu-buffer))
(jdh-smenu-redraw)
(goto-char (point-min))
(forward-line jdh--smenu-table-offset)
(jdh-smenu-mode)
)
(defun jdh-get-match-url (match-item)
"Extract the normalized url from a matched item."
(let* ((url-file-base (car match-item))
(file-path (cdr match-item))
(url (concat-path url-file-base file-path)))
(jdh-normalize-url url))
)
(defun jdh-get-match-base-url (match-item)
"Extract the base url from a matched item."
(car match-item)
)
(defun jdh-normalize-url (url)
"Normalize local file url."
(cond ((jdh-http-p url) url)
((string-match "^/" url) (concat "file://" url))
(t (concat "file:///" url)))
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Thing-at-point helper functions
; Set up bound searching method for (thing-at-point 'java-identifier)
(require 'thingatpt)
(put 'java-identifier 'bounds-of-thing-at-point
(lambda ()
"Determine where a Java identifier begins and ends for (thing-at-point 'java-identifier)"
(save-excursion
(skip-chars-backward "[a-zA-Z0-9_\\$]") ; move back through $_ALPHANUM
(if (looking-at "[a-zA-Z_\\$][a-zA-Z0-9_\\$]+") ; match ahead through $_ALPHANUM
(cons (point) (match-end 0))
nil))))
(defun jdh-refresh-url (url-file-base)
"Refresh and download the allclasses-file from the online javadoc url."
(if (not (file-accessible-directory-p javadoc-help-cache-dir))
(make-directory javadoc-help-cache-dir))
(when (jdh-http-p url-file-base)
(let* ((allclasses-url (jdh-get-allclasses-url-file url-file-base))
(allclasses-file (jdh-get-allclasses-local-file url-file-base)))
(jdh-download-url allclasses-url allclasses-file)))
)
(defun jdh-download-url (url file-to-save)
"Download the content of a url to a file"
(let ((buffer (url-retrieve-synchronously url))
(status nil))
(unwind-protect
(with-current-buffer buffer
(save-excursion
(url-http-parse-response)
(goto-char url-http-end-of-headers)
(if (or (< url-http-response-status 200)
(>= url-http-response-status 300))
(error (format "Fail to download %s. Http Response code: %d" url url-http-response-status))
(write-region (point) (point-max) file-to-save)
(setq status t))
)
)
(kill-buffer buffer))
status)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; *Javadoc-Search-Result* menu functions
(defconst jdh--smenu-table-offset 7)
(defun jdh-smenu-redraw ()
"Redraw the javadoc-help javadocs in the buffer named `*Javadoc-Search-Result*'."
(save-excursion
(save-window-excursion
(setq inhibit-read-only t)
(erase-buffer)
(insert (concat jdh--smenu-buffer "\n\n"))
(insert "Javadoc search matches. Select one for browsing.\n")
(insert "Command: [enter], o, v, m, p, q. Press '?' for help.\n\n")
(insert " Javadoc Matches\n")
(insert " -------------------------------------------------------------------------\n")
(mapc
(lambda (matched-item)
(insert (format " %s\n" (jdh-matched-to-str matched-item)))
)
*jdh-matched-search*)
))
)
(defun jdh-matched-to-str (matched-item)
(let ((url-file-base (car matched-item))
(file-path (cdr matched-item)))
(format "%-60s [%s]" (jdh-file-to-class file-path) url-file-base))
)
(defun jdh-file-to-class (file-path)
"pkg1/pkg2/class3.html => pkg1.pkg2.class3"
(let ((class-path (replace-regexp-in-string "\\.html$" "" file-path)))
(replace-regexp-in-string "/" "." class-path))
)
(defun jdh-smenu-get-javadoc-index ()
"Return a javadoc index under the cursor. Index might be out of range."
(1- (- (line-number-at-pos) jdh--smenu-table-offset))
)
(defun jdh-smenu-valid-javadoc ()
"Check whether the cursor is on a valid javadoc"
(let ((index (jdh-smenu-get-javadoc-index)))
(cond ((< index 0) nil)
((>= index (length *jdh-matched-search*)) nil)
(t (nth index *jdh-matched-search*))))
)
(defun jdh-smenu-advance-cursor ()
(forward-line 1)
(when (null (jdh-smenu-valid-javadoc))
(goto-char (point-min))
(forward-line jdh--smenu-table-offset))
)
(defun jdh-smenu-launch-url (close-buffer)
"Open the javadoc under cursor in the system web browser."
(let ((matched-item (jdh-smenu-valid-javadoc)))
(if (null matched-item)
(message "No valid javadoc selected.")
(let ((url (jdh-get-match-url matched-item)))
(save-window-excursion (browse-url url))
(when close-buffer
(jdh-close-buffer))))))
(defun jdh-smenu-open-url ()
"Open the javadoc under cursor in the system web browser."
(interactive)
(jdh-smenu-launch-url t)
)
(defun jdh-smenu-visit-url ()
"Visit the javadoc under cursor in the system web browser."
(interactive)
(jdh-smenu-launch-url nil)
)
(defun jdh-smenu-open-main ()
"Open the javadoc under cursor in the system web browser."
(interactive)
(let ((matched-item (jdh-smenu-valid-javadoc)))
(if (null matched-item)
(message "No valid javadoc selected.")
(let* ((base-url (jdh-get-match-base-url matched-item))
(main-url (jdh-normalize-url(concat-path base-url "index.html"))))
(browse-url main-url)))))
(defun jdh-smenu-open-parent ()
"Open the parent package of the javadoc under cursor in the browser."
(interactive)
(let ((matched-item (jdh-smenu-valid-javadoc)))
(if (null matched-item)
(message "No valid javadoc selected.")
(let* ((url (jdh-get-match-url matched-item))
(parent-url (path-parent url))
(package-url (concat-path parent-url "package-summary.html")))
(message (format "Launching web browser on %s" parent-url))
(browse-url package-url)
)))
)
(defun path-parent (path)
(let ((continue t)
(pos)
(previous-pos 0))
(while continue
(setq pos (string-match "/" path (1+ previous-pos)))
(if pos
(setq previous-pos pos)
(setq continue nil)))
(substring path 0 previous-pos))
)
(defvar *jdh-smenu-mode-map* nil)
(progn
(setq *jdh-smenu-mode-map* (make-keymap))
(suppress-keymap *jdh-smenu-mode-map* t)
(define-key *jdh-smenu-mode-map* "q" 'jdh-close-buffer)
(define-key *jdh-smenu-mode-map* "\C-g" 'jdh-close-buffer)
(define-key *jdh-smenu-mode-map* "o" 'jdh-smenu-open-url)
(define-key *jdh-smenu-mode-map* "\C-m" 'jdh-smenu-open-url)
(define-key *jdh-smenu-mode-map* "v" 'jdh-smenu-visit-url)
(define-key *jdh-smenu-mode-map* "m" 'jdh-smenu-open-main)
(define-key *jdh-smenu-mode-map* "p" 'jdh-smenu-open-parent)
(define-key *jdh-smenu-mode-map* "n" 'next-line)
(define-key *jdh-smenu-mode-map* " " 'next-line)
(define-key *jdh-smenu-mode-map* "?" 'describe-mode)
)
(defun jdh-smenu-mode ()
"Major mode for selecting a javadoc to browse.
The following commands are available.
\\<*jdh-smenu-mode-map*>
\\[jdh-smenu-open-url] -- Open the selected javadoc in the system web browser.
\\[jdh-smenu-visit-url] -- Open the selected javadoc in the browser. Don't close search result buffer.
\\[jdh-smenu-open-main] -- Open the main javadoc index page in the browser.
\\[jdh-smenu-open-parent] -- Open the parent package javadoc page in the browser.
\\[next-line] -- move to the next line
\\[jdh-close-buffer] -- close the *Javadoc-Search-Result* window
"
(kill-all-local-variables)
(use-local-map *jdh-smenu-mode-map*)
(setq truncate-lines t)
(setq buffer-read-only t)
(setq major-mode 'jdh-smenu-mode)
(setq mode-name jdh--smenu-mode-name)
(run-hooks 'javadoc-hook)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Util functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(unless (fboundp 'line-number-at-pos)
(defun line-number-at-pos (&optional pos)
"Return (narrowed) buffer line number at position POS. If POS is nil, use current buffer location."
(let ((opoint (or pos (point))) start)
(save-excursion
(goto-char (point-min))
(setq start (point))
(goto-char opoint)
(forward-line 0)
(1+ (count-lines start (point))))))
)
(defun jdh-close-buffer ()
"Make closing buffer work for both Emacs and XEmacs"
(interactive)
(if (not (one-window-p))
(delete-window)
(if (fboundp 'quit-window)
(quit-window)
(bury-buffer)))
)
(defun string-ltrim (str)
(let ((trim-pos (string-match "\\s +$" str)))
(if trim-pos
(substring str 0 trim-pos)
str))
)
(defun string-rtrim (str)
(let ((trim-pos (string-match "[^ \t]+" str)))
(if trim-pos
(substring str trim-pos)
str))
)
(defun string-trim (str)
(string-rtrim (string-ltrim str))
)
(defun concat-path (base-path sub-path)
(cond ((= (length base-path) 0) sub-path)
((= (length sub-path) 0) base-path)
((equal (substring base-path (1- (length base-path))) "/") (concat base-path sub-path))
(t (concat base-path "/" sub-path)))
)
(defun jdh-http-p (url)
(eq (string-match "^[Hh][Tt][Tt][Pp][Ss]?://" url) 0)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Testing and debugging
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Testing/debugging with C-xC-e
(if nil
(progn
(global-set-key [(f1)] 'javadoc-lookup)
(global-set-key [(meta f1)] 'javadoc-help)
(global-set-key [(shift f1)] 'javadoc-help)
(global-set-key "\C-x\M-t" 'jdh-debug-test)
*jdh-javadocs*
(jdh-javadocs-load-file javadoc-help-setting-file)
(jdh-javadocs-save-file *jdh-javadocs* javadoc-help-setting-file)
(jdh-javadocs-save)
(jdh-javadocs-restore)
(jdh-get-allclasses-files)
)
(defun jdh-debug-test ()
(interactive)
(skip-chars-b$_ackward "[a-zA-Z0-9_\\$]")
(message (format "%d " (point)))
)
(defun jdh-debug-test ()
(interactive)
(skip-chars-backward "[[:alnum:]_\\$]")
(message (format "%d " (point)))
(if (looking-at "[[:alpha:]_\\$][[:alnum:]_\\$]+")
(message (format "%d %d" (point) (match-end 0)))
(message "none"))
)
)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(provide 'javadoc-help)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; javadoc-help.el ends here
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Jump to Line
Something went wrong with that request. Please try again.