(eval-when-compile (require 'cl))
(require 'wid-edit)
(if (not (fboundp 'make-overlay))
(require 'overlay))
(autoload 'custom-menu-create "cus-edit")
(defgroup ph nil
"CCSO (PH/QI) directory system client"
:group 'mail
:group 'comm)
(defcustom ph-server nil
"*The name or IP address of the CCSO (PH/QI) server.
A port number may be specified by appending a colon and a
number to the name of the server."
:type '(choice (string :tag "Server")
(const nil))
:group 'ph)
(defcustom ph-strict-return-matches t
"*If non-nil, entries not containing all requested return fields are ignored."
:type 'boolean
:group 'ph)
(defcustom ph-default-return-fields nil
"*A list of the default fields to extract from CCSO entries.
If it contains `all' then all available fields are returned.
nil means return the default fields as configured in the server."
:type '(repeat (symbol :tag "Field name"))
:group 'ph)
(defcustom ph-multiple-match-handling-method 'select
"*What to do when multiple entries match an inline expansion query.
Possible values are:
`first' (equivalent to nil) which means consider the first match,
`select' pop-up a selection buffer,
`all' use all matches,
`abort' the operation is aborted, an error is signaled."
:type '(choice :menu-tag "Method"
(const :menu-tag "First" first)
(const :menu-tag "Select" select)
(const :menu-tag "All" all)
(const :menu-tag "Abort" abort)
(const :menu-tag "None" nil))
:group 'ph)
(defcustom ph-duplicate-fields-handling-method '((email . duplicate))
"*A method to handle entries containing duplicate fields.
This is either an alist (FIELD . METHOD) or a symbol METHOD.
The alist form of the variable associates a method to an individual field,
the second form specifies a method applicable to all fields.
Available methods are:
`list' or nil lets the value of the field be a list of values,
`first' keeps the first value and discards the others,
`concat' concatenates the values into a single multiline string,
`duplicate' duplicates the entire entry into as many instances as
different values."
:type '(choice (const :menu-tag "List" list)
(const :menu-tag "First" first)
(const :menu-tag "Concat" concat)
(const :menu-tag "Duplicate" duplicate)
(repeat :menu-tag "Per Field Specification"
:tag "Per Field Specification"
(cons :tag "Field/Method"
:value (nil . list)
(symbol :tag "Field name")
(choice :tag "Method"
:menu-tag "Method"
(const :menu-tag "List" list)
(const :menu-tag "First" first)
(const :menu-tag "Concat" concat)
(const :menu-tag "Duplicate" duplicate)))))
:group 'ph
)
(defcustom ph-inline-query-format-list nil
"*Format of an inline expansion query.
If the inline query string consists of several words, this list specifies
how these individual words are associated to CCSO database field names.
If nil all the words will be mapped onto the default CCSO database key."
:type '(repeat (symbol :tag "Field name"))
:group 'ph)
(defcustom ph-expanding-overwrites-query t
"*If non nil, expanding a query overwrites the query string."
:type 'boolean
:group 'ph)
(defcustom ph-inline-expansion-format '("%s" email)
"*A list specifying the format of the expansion of inline queries.
This variable controls what `ph-expand-inline' actually inserts in the buffer.
First element is a string passed to `format'. Remaining elements are symbols
indicating CCSO database field names, corresponding field values are passed
as additional arguments to `format'."
:type '(list (string :tag "Format String")
(repeat :inline t
:tag "Field names"
(symbol :tag "")))
:group 'ph)
(defcustom ph-form-fields '(name email phone)
"*A list of fields presented in the query form."
:tag "Default Fields in Query Forms"
:type '(repeat (symbol :tag "Field name"))
:group 'ph)
(defcustom ph-fieldname-formstring-alist '((url . "URL")
(callsign . "HAM Call Sign")
(id . "ID")
(email . "E-Mail")
(firstname . "First Name"))
"*Map CCSO database field names into prompt strings for query/response.
Prompt strings for fields that are not listed here
are derived by splitting the field name
at `_' signs and capitalizing the individual words."
:tag "Mapping of Field Names onto Prompt Strings"
:type '(repeat (cons :tag "Field"
(symbol :tag "Name")
(string :tag "Prompt string")))
:group 'ph)
(defcustom ph-bbdb-conversion-alist
'((name . name)
(net . email)
(address . (ph-bbdbify-address address "Address"))
(phone . ((ph-bbdbify-phone phone "Phone")
(ph-bbdbify-phone office_phone "Office Phone"))))
"*A mapping from BBDB to PH/QI fields.
This is a list of cons cells (BBDB-FIELD . SPEC-OR-LIST) where
BBDB-FIELD is the name of a field that must be defined in your BBDB
environment (standard field names are `name', `company', `net', `phone',
`address' and `notes'). SPEC-OR-LIST is either a single SPEC or a list
of SPECs. Lists of specs are valid only for the `phone' and `address'
BBDB fields. SPECs are sexps which are evaluated:
a string evaluates to itself,
a symbol evaluates to the symbol value. Symbols naming PH/QI fields
present in the record evaluate to the value of the field in the record,
a form is evaluated as a function. The argument list may contain PH/QI
field names which eval to the corresponding values in the
record. The form evaluation should return something appropriate for
the particular BBDB-FIELD (see `bbdb-create-internal').
`ph-bbdbify-phone' and `ph-bbdbify-address' are provided as convenience
functions to parse phones and addresses."
:tag "BBDB to CCSO Field Name Mapping"
:type '(repeat (cons :tag "Field Name"
(symbol :tag "BBDB Field")
(sexp :tag "Conversion Spec")))
:group 'ph)
(defcustom ph-options-file "~/.ph-options"
"*A file where the PH `servers' hotlist is stored."
:type '(file :Tag "File Name:"))
(defcustom ph-mode-hook nil
"*Normal hook run on entry to PH mode."
:type '(repeat (sexp :tag "Hook")))
(defconst ph-xemacs-p (string-match "XEmacs" emacs-version))
(defconst ph-emacs-p (not ph-xemacs-p))
(defconst ph-xemacs-mule-p (and ph-xemacs-p
(featurep 'mule)))
(defconst ph-emacs-mule-p (and ph-emacs-p
(featurep 'mule)))
(defvar ph-server-hotlist nil)
(defconst ph-default-server-port 105
"Default TCP port for CCSO directory services.")
(defvar ph-form-widget-list nil)
(defvar ph-process-buffer nil)
(defvar ph-read-point)
(if (and (and (locate-library ph-options-file)
(message "")) (not (featurep 'ph-options-file)))
(load ph-options-file))
(defun ph-cadr (obj)
(car (cadr obj)))
(defun ph-cdar (obj)
(cdr (car obj)))
(defun ph-mode ()
"Major mode used in buffers displaying the results of PH queries.
There is no sense in calling this command from a buffer other than
one containing the results of a PH query.
These are the special commands of PH mode:
q -- kill this buffer.
f -- Display a form to query the CCSO PH/QI nameserver.
n -- Move to next record.
p -- Move to previous record."
(interactive)
(kill-all-local-variables)
(setq major-mode 'ph-mode)
(setq mode-name "PH")
(use-local-map ph-mode-map)
(setq mode-popup-menu (ph-menu))
(run-hooks 'ph-mode-hook)
)
(defun ph-display-records (records &optional raw-field-names)
"Display the record list RECORDS in a formatted buffer.
If RAW-FIELD-NAMES is non-nil, the raw field names are displayed
otherwise they are formatted according to `ph-fieldname-formstring-alist'."
(let ((buffer (get-buffer-create "*PH Query Results*"))
inhibit-read-only
precords
(width 0)
beg field-beg
field-name)
(switch-to-buffer buffer)
(setq buffer-read-only t)
(setq inhibit-read-only t)
(erase-buffer)
(insert "PH Query Result\n")
(insert "===============\n\n\n")
(if (null records)
(insert "No match found.\n"
(if ph-strict-return-matches
"Try setting ph-strict-return-matches to nil or change ph-default-return-fields."
""))
(setq precords
(mapcar
(function
(lambda (record)
(mapcar
(function
(lambda (field)
(setq field-name (if raw-field-names
(symbol-name (car field))
(or (and (assq (car field) ph-fieldname-formstring-alist)
(cdr (assq (car field) ph-fieldname-formstring-alist)))
(capitalize (mapconcat '(lambda (char)
(if (eq char ?_)
" "
(char-to-string char)))
(symbol-name (car field))
"")))))
(if (> (length field-name) width)
(setq width (length field-name)))
(cons field-name (cdr field))))
record)))
records))
(mapcar (function
(lambda (record)
(setq beg (point))
(mapcar (function
(lambda (field)
(setq field-beg (point))
(insert (format (concat "%" width "s: ") (car field)))
(put-text-property field-beg (point) 'face 'bold)
(mapcar (function
(lambda (val)
(indent-to (+ 2 width))
(insert val "\n")))
(if (stringp (cdr field))
(split-string (cdr field) "\n")
(cdr field)))))
record)
(overlay-put (make-overlay beg (point))
'ph-record
(car records))
(setq records (cdr records))
(insert "\n")))
precords))
(insert "\n")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(ph-query-form))
"New query")
(widget-insert " ")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(kill-this-buffer))
"Quit")
(ph-mode)
(widget-setup)
)
)
(defun ph-process-form ()
"Process the form in current buffer and display the results."
(let (query-alist
value)
(if (not (and (boundp 'ph-form-widget-list)
ph-form-widget-list))
(error "Not in a PH query form buffer")
(mapcar (function
(lambda (wid-field)
(setq value (widget-value (cdr wid-field)))
(if (not (string= value ""))
(setq query-alist (cons (cons (car wid-field) value)
query-alist)))))
ph-form-widget-list)
(kill-buffer (current-buffer))
(ph-display-records (ph-query-internal query-alist))
)))
(defun ph-query-internal (query &optional return-fields)
"Query the PH/QI server with QUERY.
QUERY can be a string NAME or a list made of strings NAME
and/or cons cells (KEY . VALUE) where KEYs should be valid
CCSO database keys. NAME is equivalent to (DEFAULT . NAME),
where DEFAULT is the default key of the database.
RETURN-FIELDS is a list of database fields to return,
defaulting to `ph-default-return-fields'."
(let (request)
(if (null return-fields)
(setq return-fields ph-default-return-fields))
(setq request
(concat "query "
(if (stringp query)
query
(mapconcat (function (lambda (elt)
(if (stringp elt) elt)
(format "%s=%s" (car elt) (cdr elt))))
query
" "))
(if return-fields
(concat " return " (mapconcat 'symbol-name return-fields " ")))))
(and (> (length request) 6)
(ph-do-request request)
(ph-parse-query-result return-fields))))
(defun ph-parse-query-result (&optional fields)
"Return a list of alists of key/values from in `ph-process-buffer'.
Fields not in FIELDS are discarded."
(let (record
records
line-regexp
current-key
key
value
ignore)
(save-excursion
(message "Parsing results...")
(set-buffer ph-process-buffer)
(goto-char (point-min))
(while (re-search-forward "^\\(-[0-9]+\\):\\([0-9]+\\):" nil t)
(catch 'ignore
(setq line-regexp (concat "^\\(-[0-9]+\\):" (match-string 2) ":[ \t]*\\([-a-zA-Z_]*\\)?:[ \t]*\\(.*\\)$"))
(beginning-of-line)
(setq record nil
ignore nil
current-key nil)
(while (re-search-forward line-regexp nil t)
(catch 'skip-line
(if (string= "-508" (match-string 1))
(if (not ph-strict-return-matches)
(throw 'skip-line t)
(while (re-search-forward line-regexp nil t))
(setq ignore t)
(throw 'ignore t)))
(setq key (and (not (string= (match-string 2) ""))
(intern (match-string 2)))
value (match-string 3))
(if (and current-key
(eq key current-key))
(setq key nil)
(setq current-key key))
(if (or (null fields)
(memq 'all fields)
(memq current-key fields))
(if key
(setq record (cons (cons key value) record)) (setcdr (car record) (if (listp (ph-cdar record))
(append (ph-cdar record) (list value))
(list (ph-cdar record) value))))))))
(and (not ignore)
(or (null fields)
(memq 'all fields)
(setq record (nreverse record)))
(setq record (if (not (eq 'list ph-duplicate-fields-handling-method))
(ph-filter-duplicate-fields record)
(list record)))
(setq records (append record records))))
)
(message "Done")
records)
)
(defun ph-filter-duplicate-fields (record)
"Filter RECORD according to `ph-duplicate-fields-handling-method'."
(let ((rec record)
unique
duplicates
result)
(while (and rec
(not (listp (ph-cdar rec))))
(setq rec (cdr rec)))
(if (null (ph-cdar rec))
(list record) (mapcar (function
(lambda (field)
(if (listp (cdr field))
(setq duplicates (cons field duplicates))
(setq unique (cons field unique)))))
record)
(setq result (list unique))
(mapcar (function
(lambda (field)
(let ((method (if (consp ph-duplicate-fields-handling-method)
(cdr (assq (car field) ph-duplicate-fields-handling-method))
ph-duplicate-fields-handling-method)))
(cond
((or (null method) (eq 'list method))
(setq result
(ph-add-field-to-records field result)))
((eq 'first method)
(setq result
(ph-add-field-to-records (cons (car field) (ph-cadr field)) result)))
((eq 'concat method)
(setq result
(ph-add-field-to-records (cons (car field)
(mapconcat
'identity
(cdr field)
"\n")) result)))
((eq 'duplicate method)
(setq result
(ph-distribute-field-on-records field result)))))))
duplicates)
result)))
(defun ph-add-field-to-records (field records)
"Add FIELD to each individual record in RECORDS and return the resulting list."
(mapcar (function
(lambda (r)
(cons field r)))
records))
(defun ph-distribute-field-on-records (field records)
"Duplicate each individual record in RECORDS according to value of FIELD.
Each copy is added a new field containing one of the values of FIELD."
(let (result
(values (cdr field)))
(while values
(setcdr values (delete (car values) (cdr values)))
(setq values (cdr values)))
(mapcar (function
(lambda (value)
(let ((result-list (copy-sequence records)))
(setq result-list (ph-add-field-to-records (cons (car field) value)
result-list))
(setq result (append result-list result))
)))
(cdr field))
result)
)
(defun ph-do-request (request)
"Send REQUEST to the server.
Wait for response and return the buffer containing it."
(let (process
buffer)
(unwind-protect
(progn
(message "Contacting server...")
(setq process (ph-open-session))
(if process
(save-excursion
(set-buffer (setq buffer (process-buffer process)))
(ph-send-command process request)
(message "Request sent, waiting for reply...")
(ph-read-response process))))
(if process
(ph-close-session process)))
buffer))
(defun ph-open-session (&optional server)
"Open a connection to the given CCSO SERVER.
SERVER is either a string naming the server or a list (NAME PORT)."
(let (process
host
port)
(catch 'done
(if (null server)
(setq server (or ph-server
(call-interactively 'ph-set-server))))
(string-match "\\(.*\\)\\(:\\(.*\\)\\)?" server)
(setq host (match-string 1 server))
(setq port (or (match-string 3 server)
ph-default-server-port))
(setq ph-process-buffer (get-buffer-create (format " *PH-%s*" host)))
(save-excursion
(set-buffer ph-process-buffer)
(erase-buffer)
(setq ph-read-point (point))
(and ph-xemacs-mule-p
(set-buffer-file-coding-system 'binary t)))
(setq process (open-network-stream "ph" ph-process-buffer host port))
(if (null process)
(throw 'done nil))
(process-kill-without-query process)
process)))
(defun ph-close-session (process)
(save-excursion
(set-buffer (process-buffer process))
(ph-send-command process "quit")
(ph-read-response process)
(if (fboundp 'add-async-timeout)
(add-async-timeout 10 'delete-process process)
(run-at-time 2 nil 'delete-process process))))
(defun ph-send-command (process command)
(goto-char (point-max))
(process-send-string process command)
(process-send-string process "\r\n")
)
(defun ph-read-response (process &optional return-response)
"Read a response from the PH/QI query process PROCESS.
Returns nil if response starts with an error code. If the
response is successful the return code or the reponse itself is returned
depending on RETURN-RESPONSE."
(let ((case-fold-search nil)
return-code
match-end)
(goto-char ph-read-point)
(while (not (re-search-forward "^\\(^[2-5].*\\):.*\n" nil t))
(accept-process-output process)
(goto-char ph-read-point))
(setq match-end (point))
(goto-char ph-read-point)
(if (and (setq return-code (match-string 1))
(setq return-code (string-to-number return-code))
(>= (abs return-code) 300))
(progn (setq ph-read-point match-end) nil)
(setq ph-read-point match-end)
(if return-response
(buffer-substring (point) match-end)
return-code))))
(defun ph-create-bbdb-record (record)
"Create a BBDB record using the RECORD alist.
RECORD is an alist of (KEY . VALUE) where KEY is a symbol naming a field
of the PH/QI database and VALUE is the corresponding value for the record."
(eval
`(let* (,@(mapcar '(lambda (c)
(list (car c) (if (listp (cdr c))
(list 'quote (cdr c))
(cdr c))))
record)
bbdb-name
bbdb-company
bbdb-net
bbdb-address
bbdb-phones
bbdb-notes
spec
bbdb-record
value)
(setq bbdb-name (ph-parse-spec (cdr (assq 'name ph-bbdb-conversion-alist)) record nil)
bbdb-company (ph-parse-spec (cdr (assq 'company ph-bbdb-conversion-alist)) record nil)
bbdb-net (ph-parse-spec (cdr (assq 'net ph-bbdb-conversion-alist)) record nil)
bbdb-notes (ph-parse-spec (cdr (assq 'notes ph-bbdb-conversion-alist)) record nil))
(setq spec (cdr (assq 'address ph-bbdb-conversion-alist)))
(setq bbdb-address (delq nil (ph-parse-spec (if (listp (car spec))
spec
(list spec))
record t)))
(setq spec (cdr (assq 'phone ph-bbdb-conversion-alist)))
(setq bbdb-phones (delq nil (ph-parse-spec (if (listp (car spec))
spec
(list spec))
record t)))
(setq bbdb-notes (append (list (and bbdb-notes (cons 'notes bbdb-notes)))
(mapcar (function
(lambda (mapping)
(if (and (not (memq (car mapping)
'(name company net address phone notes)))
(setq value (ph-parse-spec (cdr mapping) record nil)))
(cons (car mapping) value))))
ph-bbdb-conversion-alist)))
(setq bbdb-notes (delq nil bbdb-notes))
(setq bbdb-record (bbdb-create-internal bbdb-name
bbdb-company
bbdb-net
bbdb-address
bbdb-phones
bbdb-notes))
(bbdb-display-records (list bbdb-record))
)))
(defun ph-parse-spec (spec record recurse)
"Parse the conversion SPEC using RECORD.
If RECURSE is non-nil then SPEC may be a list of atomic specs."
(cond
((or (stringp spec)
(symbolp spec)
(and (listp spec)
(symbolp (car spec))
(fboundp (car spec))))
(condition-case nil
(eval spec)
(void-variable nil)))
((and recurse
(listp spec))
(mapcar '(lambda (spec-elem)
(ph-parse-spec spec-elem record nil))
spec))
(t
(error "Invalid specification for `%s' in `ph-bbdb-conversion-alist'" spec))))
(defun ph-bbdbify-address (addr location)
"Parse ADDR into a vector compatible with BBDB.
ADDR should be an address string of no more than four lines or a
list of lines.
The last line is searched for the zip code, city and state name.
LOCATION is used as the address location for bbdb."
(let* ((addr-components (if (listp addr)
(reverse addr)
(reverse (split-string addr "\n"))))
(lastl (pop addr-components))
zip city state)
(setq addr-components (nreverse addr-components))
(cond
((string-match "\\(\\w+\\)\\W*\\([A-Z][A-Z]\\)\\W*\\([0-9]+\\)" lastl)
(setq city (match-string 1 lastl)
state (match-string 2 lastl)
zip (string-to-number (match-string 3 lastl))))
((string-match "\\([0-9]+\\)[ \t]+\\(.*\\)" lastl)
(setq city (match-string 2 lastl)
zip (string-to-number (match-string 1 lastl))))
(t
(error "Cannot parse the address; see `ph-bbdb-conversion-alist'")))
(vector location
(or (nth 0 addr-components) "")
(or (nth 1 addr-components) "")
(or (nth 2 addr-components) "")
(or city "")
(or state "")
zip)))
(defun ph-bbdbify-phone (phone location)
"Parse PHONE into a vector compatible with BBDB.
PHONE is either a string supposedly containing a phone number or
a list of such strings which are concatenated.
LOCATION is used as the phone location for bbdb."
(cond
((stringp phone)
(let (phone-list)
(condition-case err
(setq phone-list (bbdb-parse-phone-number phone))
(error
(if (string= "phone number unparsable." (ph-cadr err))
(if (not (y-or-n-p (format "BBDB claims %S to be unparsable--insert anyway? " phone)))
(error "Phone number unparsable")
(setq phone-list (list (bbdb-string-trim phone))))
(signal (car err) (cdr err)))))
(if (= 3 (length phone-list))
(setq phone-list (append phone-list '(nil))))
(apply 'vector location phone-list)))
((listp phone)
(vector location (mapconcat 'identity phone ", ")))
(t
(error "Invalid phone specification"))))
(defun ph-customize ()
"Customize the PH package."
(interactive)
(customize-group 'ph))
(defun ph-set-server (server)
"Set the PH server to SERVER."
(interactive "sNew PH/QI Server: ")
(message "Selected PH/QI server is now %s" server)
(setq ph-server server))
(defun ph-get-email (name)
"Get the email field of NAME from the PH/QI directory server."
(interactive "sName: ")
(let ((email (cdaar (ph-query-internal name '(email)))))
(if (interactive-p)
(if email
(message "%s" email)
(message "No record matching %s" name)))
email))
(defun ph-get-phone (name)
"Get the phone field of NAME from the PH/QI directory server."
(interactive "sName: ")
(let ((phone (cdaar (ph-query-internal name '(phone)))))
(if (interactive-p)
(if phone
(message "%s" phone)
(message "No record matching %s" name)))
phone))
(defun ph-get-field-list ()
"Return a list of valid field names for current server.
When called interactively the list is formatted in a dedicated buffer
otherwise a list of symbols is returned."
(interactive)
(ph-do-request "fields")
(if (interactive-p)
(let ((ph-duplicate-fields-handling-method 'list))
(ph-display-records (ph-parse-query-result) t))
(mapcar 'caar
(ph-parse-query-result)))
)
(defun ph-expand-inline (&optional replace)
"Query the PH server, and expand the query string before point.
The query string consists of the buffer substring from the point back to
the preceding comma, colon or beginning of line. If it contains more than
one word, the variable `ph-inline-query-format-list' controls to map these
onto CCSO database field names.
After querying the server for the given string, the expansion specified by
`ph-inline-expansion-format' is inserted in the buffer at point.
If REPLACE is t, then this expansion replaces the name in the buffer.
If `ph-expanding-overwrites-query' is t, that inverts the meaning of REPLACE."
(interactive)
(let* ((end (point))
(beg (save-excursion
(if (re-search-backward "[:,][ \t]*"
(save-excursion
(beginning-of-line)
(point))
'move)
(goto-char (match-end 0)))
(point)))
(words (buffer-substring beg end))
query
query-alist
(query-format ph-inline-query-format-list)
response
response-strings
key val cell)
(if (or (not query-format)
(not (string-match "[ \t]+" words)))
(setq query words)
(setq words (split-string words "[ \t]+"))
(while (and words query-format)
(setq query-alist (cons (cons (car query-format) (car words)) query-alist))
(setq words (cdr words)
query-format (cdr query-format)))
(if words
(setcdr (car query-alist)
(concat (ph-cdar query-alist) " "
(mapconcat 'identity words " "))))
(setq query-alist (nreverse query-alist))
(while query-alist
(setq key (caar query-alist)
val (ph-cdar query-alist)
cell (assq key query))
(if cell
(setcdr cell (concat val " " (cdr cell)))
(setq query (cons (car query-alist) query))))
(setq query-alist (cdr query-alist)))
(setq response (ph-query-internal query (cdr ph-inline-expansion-format)))
(if (null response)
(error "No match found")
(while response
(setq response-strings
(cons (apply 'format
(car ph-inline-expansion-format)
(mapcar (function
(lambda (field)
(or (cdr (assq field (car response)))
"")))
(cdr ph-inline-expansion-format)))
response-strings))
(setq response (cdr response)))
(if (or
(and replace (not ph-expanding-overwrites-query))
(and (not replace) ph-expanding-overwrites-query))
(delete-region beg end))
(cond
((or (= (length response-strings) 1)
(null ph-multiple-match-handling-method)
(eq ph-multiple-match-handling-method 'first))
(insert (car response-strings)))
((eq ph-multiple-match-handling-method 'select)
(with-output-to-temp-buffer "*Completions*"
(display-completion-list response-strings)))
((eq ph-multiple-match-handling-method 'all)
(insert (mapconcat 'identity response-strings ", ")))
((eq ph-multiple-match-handling-method 'abort)
(error "There is more than one match for the query"))
))
)
)
(defun ph-query-form (&optional get-fields-from-server)
"Display a form to query the CCSO PH/QI nameserver.
If given a non-nil argument the function first queries the server
for the existing fields and displays a corresponding form."
(interactive "P")
(let ((fields (or (and get-fields-from-server
(ph-get-field-list))
ph-form-fields))
(buffer (get-buffer-create "*PH/QI Query Form*"))
field-name
widget
(width 0)
inhibit-read-only
pt)
(switch-to-buffer buffer)
(setq inhibit-read-only t)
(erase-buffer)
(kill-all-local-variables)
(make-local-variable 'ph-form-widget-list)
(widget-insert "PH/QI Query Form\n")
(widget-insert "================\n\n")
(widget-insert "Current server is: " (or ph-server
(call-interactively 'ph-set-server)) "\n")
(setq fields
(mapcar (function
(lambda (field)
(setq field-name (or (and (assq field ph-fieldname-formstring-alist)
(cdr (assq field ph-fieldname-formstring-alist)))
(capitalize (symbol-name field))))
(if (> (length field-name) width)
(setq width (length field-name)))
(cons field field-name)))
fields))
(widget-insert "\n\n" (format (concat "%" width "s: ") (cdr (car fields))))
(setq pt (point))
(setq widget (widget-create 'editable-field :size 15))
(setq ph-form-widget-list (cons (cons (car (car fields)) widget)
ph-form-widget-list))
(setq fields (cdr fields))
(mapcar (function
(lambda (field)
(widget-insert "\n\n" (format (concat "%" width "s: ") (cdr field)))
(setq widget (widget-create 'editable-field
:size 15))
(setq ph-form-widget-list (cons (cons (car field) widget)
ph-form-widget-list))))
fields)
(widget-insert "\n\n")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(ph-process-form))
"Query Server")
(widget-insert " ")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(ph-query-form))
"Reset Form")
(widget-insert " ")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(kill-this-buffer))
"Quit")
(goto-char (1+ pt)) (use-local-map widget-keymap)
(widget-setup))
)
(defun ph-bookmark-server (server)
"Add SERVER to the PH `servers' hotlist."
(interactive "sPH server: ")
(if (member server ph-server-hotlist)
(error "%s is already in the hotlist" server)
(setq ph-server-hotlist (cons server ph-server-hotlist))
(ph-install-menu)
(ph-save-options)))
(defun ph-bookmark-current-server ()
"Add current server to the PH `servers' hotlist."
(interactive)
(ph-bookmark-server ph-server))
(defun ph-save-options ()
"Save options (essentially the hotlist) to `ph-options-file'."
(interactive)
(save-excursion
(set-buffer (find-file-noselect ph-options-file t))
(let ((standard-output (current-buffer))
provide-p
setq-p)
(catch 'found
(while t
(let ((sexp (condition-case nil
(read (current-buffer))
(end-of-file (throw 'found nil)))))
(if (listp sexp)
(progn
(if (and (eq (car sexp) 'setq)
(eq (ph-cadr sexp) 'ph-server-hotlist))
(progn
(delete-region (save-excursion
(backward-sexp)
(point))
(point))
(setq setq-p t)))
(if (and (eq (car sexp) 'provide)
(equal (ph-cadr sexp) '(quote ph-options-file)))
(setq provide-p t))
(if (and provide-p
setq-p)
(throw 'found t)))))))
(if (eq (point-min) (point-max))
(princ ";; This file was automatically generated by ph.el\n\n"))
(if (not (bolp))
(princ "\n"))
(princ "(setq ph-server-hotlist '")
(prin1 ph-server-hotlist)
(princ ")\n")
(if (not provide-p)
(princ "(provide 'ph-options-file)\n"))
(save-buffer)))
)
(defun ph-insert-record-at-point-into-bbdb ()
"Insert record at point into the BBDB database.
This function can only be called from a PH/QI query result buffer."
(interactive)
(let ((record (and (overlays-at (point))
(overlay-get (car (overlays-at (point))) 'ph-record))))
(if (null record)
(error "Point is not over a record")
(ph-create-bbdb-record record))))
(defun ph-try-bbdb-insert ()
"Call `ph-insert-record-at-point-into-bbdb' if on a record."
(interactive)
(and (or (featurep 'bbdb)
(prog1 (locate-library "bbdb") (message "")))
(overlays-at (point))
(overlay-get (car (overlays-at (point))) 'ph-record)
(ph-insert-record-at-point-into-bbdb)))
(defun ph-move-to-next-record ()
"Move to next record, in a buffer displaying PH query results."
(interactive)
(if (not (eq major-mode 'ph-mode))
(error "Not in a PH buffer")
(let ((pt (next-overlay-change (point))))
(if (< pt (point-max))
(goto-char (1+ pt))
(error "No more records after point")))))
(defun ph-move-to-previous-record ()
"Move to previous record, in a buffer displaying PH query results."
(interactive)
(if (not (eq major-mode 'ph-mode))
(error "Not in a PH buffer")
(let ((pt (previous-overlay-change (point))))
(if (> pt (point-min))
(goto-char pt)
(error "No more records before point")))))
(require 'easymenu)
(defvar ph-mode-map (let ((map (make-sparse-keymap)))
(define-key map "q" 'kill-this-buffer)
(define-key map "x" 'kill-this-buffer)
(define-key map "f" 'ph-query-form)
(define-key map "b" 'ph-try-bbdb-insert)
(define-key map "n" 'ph-move-to-next-record)
(define-key map "p" 'ph-move-to-previous-record)
map))
(set-keymap-parent ph-mode-map widget-keymap)
(defconst ph-tail-menu
`(["---" nil nil]
["Query Form" ph-query-form t]
["Expand Inline" ph-expand-inline t]
["---" nil nil]
["Get Email" ph-get-email t]
["Get Phone" ph-get-phone t]
["List Valid Field Names" ph-get-field-list t]
["---" nil nil]
,(cons "Customize" (cdr (custom-menu-create 'ph)))))
(defconst ph-server-menu
'(["---" ph-bookmark-server t]
["Bookmark Current Server" ph-bookmark-current-server t]
["New Server" ph-set-server t]))
(defun ph-menu ()
(let (command)
(append '("Ph")
(list
(append '("Server")
(mapcar (function
(lambda (server)
(setq command (intern (concat "ph-set-server-" server)))
(if (not (fboundp command))
(fset command `(lambda ()
(interactive)
(setq ph-server ,server)
(message "Selected PH/QI server is now %s" ,server))))
(vector server command t)))
ph-server-hotlist)
ph-server-menu))
ph-tail-menu)))
(defun ph-install-menu ()
(cond
(ph-xemacs-p
(add-submenu '("Tools") (ph-menu)))
(ph-emacs-p
(easy-menu-define ph-menu-map ph-mode-map "PH Menu" (ph-menu))
(define-key
global-map
[menu-bar tools ph]
(cons "Ph"
(easy-menu-create-menu "Ph" (cdr (ph-menu))))))
))
(ph-install-menu)
(provide 'ph)