+++ /dev/null
-;; Ebib v1.2.1
-;;
-;; Copyright (c) 2003-2007 Joost Kremers
-;; All rights reserved.
-;;
-;; Redistribution and use in source and binary forms, with or without
-;; modification, are permitted provided that the following conditions
-;; are met:
-;;
-;; 1. Redistributions of source code must retain the above copyright
-;; notice, this list of conditions and the following disclaimer.
-;; 2. Redistributions in binary form must reproduce the above copyright
-;; notice, this list of conditions and the following disclaimer in the
-;; documentation and/or other materials provided with the distribution.
-;; 3. The name of the author may not be used to endorse or promote products
-;; derived from this software without specific prior written permission.
-;;
-;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE,
-;; DATA, OR PROFITS ; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-(require 'cl)
-
-(defmacro add-to-listq (listvar element &optional append fn)
- (if (or (featurep 'xemacs)
- (string< emacs-version "22"))
- `(add-to-list (quote ,listvar) ,element ,append)
- `(add-to-list (quote ,listvar) ,element ,append ,fn)))
-
-;;;;;;;;;;;;;;;;;;;;;;
-;; global variables ;;
-;;;;;;;;;;;;;;;;;;;;;;
-
-;; user customisation
-
-(defgroup ebib nil "Ebib: a BibTeX database manager" :version "21.4.2" :group 'Tex)
-
-(defcustom ebib-default-type 'article
- "*The default type for a newly created BibTeX entry."
- :group 'ebib
- :type 'symbol)
-
-(defcustom ebib-preload-bib-files nil
- "*List of .bib files to load automatically when Ebib starts."
- :group 'ebib
- :type '(repeat (file :must-match t)))
-
-(defcustom ebib-additional-fields '(crossref url annote abstract keywords timestamp)
- "*Holds a list of the additional fields."
- :group 'ebib
- :type '(repeat (symbol :tag "Field")))
-
-(defcustom ebib-index-window-size 10
- "*The number of lines used for the keys buffer window."
- :group 'ebib
- :type 'integer)
-
-(defcustom ebib-insertion-strings '((1 . "\\cite{%s}"))
- "*The string to insert when calling EBIB-INSERT-BIBTEX-KEY.
-
-The directive \"%s\" is replaced with the entry key."
- :group 'ebib
- :type '(repeat (cons :tag "Insertion string" (integer :tag "Number") (string))))
-
-(defcustom ebib-sort-order nil
- "*The fields on which the BibTeX entries are to be sorted in the .bib file.
-
-Sorting is done on different sort levels, and each sort level contains one
-or more sort keys."
- :group 'ebib
- :type '(repeat (repeat :tag "Sort level" (symbol :tag "Sort field"))))
-
-(defcustom ebib-save-xrefs-first nil
- "*If true, entries with a crossref field will be saved first in the .bib-file.
-
-Setting this option has unpredictable results for the sort order
-of entries, so it is not compatible with setting the Sort Order option."
- :group 'ebib
- :type 'boolean)
-
-(defcustom ebib-use-timestamp nil
- "*If true, new entries will get a time stamp.
-
-The time stamp will be stored in a field \"timestamp\" that can
-be made visible with the `H' command in the index buffer."
- :group 'ebib
- :type 'boolean)
-
-(defcustom ebib-timestamp-format "%a %b %e %T %Y"
- "*Format of the time string used in the timestamp.
-
-The format is given directly to FORMAT-TIME-STRING, see the
-documentation of that function for details."
- :group 'ebib
- :type 'string)
-
-(defcustom ebib-print-preamble nil
- "*List of strings to be added to the LaTeX preamble used for printing the database."
- :group 'ebib
- :type '(repeat (string :tag "Add to preamble")))
-
-(defcustom ebib-print-multiline nil
- "*If set, multiline fields are included when printing the database."
- :group 'ebib
- :type 'boolean)
-
-(defcustom ebib-latex-preamble '("\\bibliographystyle{plain}")
-"*List of strings to be added to the LaTeX preamble used for LaTeXing the database."
- :group 'ebib
- :type '(repeat (string :tag "Add to preamble")))
-
-(defcustom ebib-print-tempfile ""
- "*Temporary file for use with EBIB-PRINT-DATABASE and EBIB-LATEX-DATABASE."
- :group 'ebib
- :type '(file))
-
-(defvar ebib-entry-types-hash (make-hash-table)
- "Holds the hash table containing the entry type definitions.")
-(defvar ebib-unique-field-list nil
- "Holds a list of all field names.")
-
-(defun ebib-set-entry-types-hash (var value)
- "Sets EBIB-ENTRY-TYPES-HASH on the basis of EBIB-ENTRY-TYPES"
- (set-default var value)
- (clrhash ebib-entry-types-hash)
- (setq ebib-unique-field-list nil)
- (mapc '(lambda (entry)
- (puthash (car entry) (cdr entry) ebib-entry-types-hash)
- (mapc '(lambda (field)
- (add-to-listq ebib-unique-field-list field t 'eq))
- (cadr entry))
- (mapc '(lambda (field)
- (add-to-listq ebib-unique-field-list field t 'eq))
- (caddr entry)))
- value))
-
-(defcustom ebib-entry-types
- '((article ;; name of entry type
- (author title journal year) ;; obligatory fields
- (volume number pages month note)) ;; optional fields
-
- (book
- (author title publisher year)
- (editor volume number series address edition month note))
-
- (booklet
- (title)
- (author howpublished address month year note))
-
- (inbook
- (author title chapter pages publisher year)
- (editor volume series address edition month note))
-
- (incollection
- (author title booktitle publisher year)
- (editor volume number series type chapter pages address edition month note))
-
- (inproceedings
- (author title booktitle year)
- (editor pages organization publisher address month note))
-
- (manual
- (title)
- (author organization address edition month year note))
-
- (misc
- ()
- (title author howpublished month year note))
-
- (mastersthesis
- (author title school year)
- (address month note))
-
- (phdthesis
- (author title school year)
- (address month note))
-
- (proceedings
- (title year)
- (editor publisher organization address month note))
-
- (techreport
- (author title institution year)
- (type number address month note))
-
- (unpublished
- (author title note)
- (month year)))
-
- "List of entry type definitions for Ebib"
- :group 'ebib
- :type '(repeat (list :tag "Entry type" (symbol :tag "Name")
- (repeat :tag "Obligatory fields" (symbol :tag "Field"))
- (repeat :tag "Optional fields" (symbol :tag "Field"))))
- :set 'ebib-set-entry-types-hash)
-
-;; generic for all databases
-
-;; constants and variables that are set only once
-(defconst ebib-bibtex-identifier "[^\"#%'(),={} \t\n\f]*" "Regex describing a licit BibTeX identifier.")
-(defconst ebib-version "1.2.1")
-(defvar ebib-initialized nil "T if Ebib has been initialized.")
-
-;; buffers and highlights
-(defvar ebib-index-buffer nil "The index buffer.")
-(defvar ebib-entry-buffer nil "The entry buffer.")
-(defvar ebib-strings-buffer nil "The strings buffer.")
-(defvar ebib-multiline-buffer nil "Buffer for editing multiline strings.")
-(defvar ebib-help-buffer nil "Buffer showing Ebib help.")
-(defvar ebib-index-highlight nil "Highlight to mark the current entry.")
-(defvar ebib-fields-highlight nil "Highlight to mark the current field.")
-(defvar ebib-strings-highlight nil "Highlight to mark the current string.")
-
-;; general bookkeeping
-(defvar ebib-minibuf-hist nil "Holds the minibuffer history for Ebib")
-(defvar ebib-saved-window-config nil "Stores the window configuration when Ebib is called.")
-(defvar ebib-export-filename nil "Filename to export entries to.")
-(defvar ebib-search-string nil "Stores the last search string.")
-(defvar ebib-editing nil "Indicates what the user is editing.
-Its value can be 'strings, 'fields, or 'preamble.")
-(defvar ebib-multiline-raw nil "Indicates whether the multiline text being edited is raw.")
-(defvar ebib-before-help nil "Stores the buffer the user was in when he displayed the help message.")
-(defvar ebib-local-bibtex-filename nil "A buffer-local variable holding the name of that buffer's .bib file")
-(make-variable-buffer-local 'ebib-local-bibtex-filename)
-
-;; the databases
-
-;; each database is represented by a struct
-(defstruct edb
- (database (make-hash-table :test 'equal)) ; hashtable containing the database itself
- (keys-list nil) ; sorted list of the keys in the database
- (cur-entry nil) ; sublist of KEYS-LIST that starts with the current entry
- (n-entries 0) ; number of entries stored in this database
- (strings (make-hash-table :test 'equal)) ; hashtable with the @STRING definitions
- (strings-list nil) ; sorted list of the @STRING abbreviations
- (preamble nil) ; string with the @PREAMBLE definition
- (filename nil) ; name of the BibTeX file that holds this database
- (name nil) ; name of the database
- (modified nil) ; has this database been modified?
- (make-backup nil) ; do we need to make a backup of the .bib file?
- (virtual nil)) ; is this a virtual database?
-
-;; the master list and the current database
-(defvar ebib-databases nil "List of structs containing the databases")
-(defvar ebib-cur-db nil "The database that is currently active")
-
-;;;;;; bookkeeping required when editing field values or @STRING definitions
-
-(defvar ebib-hide-hidden-fields t "If set to T, hidden fields are not shown.")
-
-;; these two variables are set when the user enters the entry buffer
-(defvar ebib-cur-entry-hash nil "The hash table containing the data of the current entry.")
-(defvar ebib-cur-entry-fields nil "The fields of the type of the current entry.")
-
-;; and these two are set by EBIB-FILL-ENTRY-BUFFER and EBIB-FILL-STRINGS-BUFFER, respectively
-(defvar ebib-current-field nil "The current field.")
-(defvar ebib-current-string nil "The current @STRING definition.")
-
-;; we define these variables here, but only give them a value at the end of
-;; the file, because the long strings mess up Emacs' syntax highlighting.
-(defvar ebib-index-buffer-help nil "Help for the index buffer.")
-(defvar ebib-entry-buffer-help nil "Help for the entry buffer.")
-(defvar ebib-strings-buffer-help nil "Help for the strings buffer.")
-
-;; this is an AucTeX variable, but we want to check its value, so let's
-;; keep the compiler from complaining.
-(eval-when-compile
- (defvar TeX-master))
-
-;; this is to keep XEmacs from complaining.
-(eval-when-compile
- (if (featurep 'xemacs)
- (defvar mark-active)))
-
-;;;;;;;;;;;;;;;;;;;;
-;; things we need ;;
-;;;;;;;;;;;;;;;;;;;;
-
-;; macro to define key bindings.
-
-(defmacro ebib-key (buffer key command)
- (cond
- ((eq buffer 'index)
- `(define-key ebib-index-mode-map (quote ,key) (quote ,command)))
- ((eq buffer 'entry)
- `(define-key ebib-entry-mode-map (quote ,key) (quote ,command)))
- ((eq buffer 'strings)
- `(define-key ebib-strings-mode-map (quote ,key) (quote ,command)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; useful macros and functions ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmacro nor (&rest args)
- "Returns T if none of its arguments are true."
- `(not (or ,@args)))
-
-;; we sometimes (often, in fact ;-) need to do something with a string, but
-;; take special action (or do nothing) if that string is empty. IF-STR
-;; makes that easier:
-
-(defmacro if-str (bindvar then &rest else)
- "Execute THEN only if STRING is nonempty.
-
-Format: (if-str (var value) then-form [else-forms])
-VAR is bound to VALUE, which is evaluated. If VAR is a nonempty string,
-THEN-FORM is executed. If VAR is either \"\" or nil, ELSE-FORM is
-executed. Returns the value of THEN or of ELSE."
- (declare (indent 2))
- `(let ,(list bindvar)
- (if (nor (null ,(car bindvar))
- (equal ,(car bindvar) ""))
- ,then
- ,@else)))
-
-;; this needs to be wrapped in an eval-and-compile, to keep Emacs from
-;; complaining that ebib-execute-helper isn't defined when it compiles
-;; ebib-execute-when.
-
-(eval-and-compile
- (defun ebib-execute-helper (env)
- "Helper function for EBIB-EXECUTE-WHEN."
- (cond
- ((eq env 'entries)
- '(and ebib-cur-db
- (edb-cur-entry ebib-cur-db)))
- ((eq env 'database)
- 'ebib-cur-db)
- ((eq env 'real-db)
- '(and ebib-cur-db
- (not (edb-virtual ebib-cur-db))))
- ((eq env 'virtual-db)
- '(and ebib-cur-db
- (edb-virtual ebib-cur-db)))
- ((eq env 'no-database)
- '(not ebib-cur-db))
- (t t))))
-
-(defmacro ebib-execute-when (&rest forms)
- "Macro to facilitate writing Ebib functions.
-
-This functions essentially like a COND clause: the basic format
-is (ebib-execute-when FORMS ...), where each FORM is built up
-as (ENVIRONMENTS BODY). ENVIRONMENTS is a list of symbols (not
-quoted) that specify under which conditions BODY is to be
-executed. Valid symbols are:
-
-entries: execute when there are entries in the database,
-database: execute if there is a database,
-no-database: execute if there is no database,
-real-db: execute when there is a database and it is real,
-virtual-db: execute when there is a database and it is virtual,
-default: execute if all else fails.
-
-Just like with COND, only one form is actually executed, the
-first one that matches. If ENVIRONMENT contains more than one
-condition, BODY is executed if they all match (i.e., the
-conditions are AND'ed.)"
- (declare (indent defun))
- `(cond
- ,@(mapcar '(lambda (form)
- (cons (if (= 1 (length (car form)))
- (ebib-execute-helper (caar form))
- `(and ,@(mapcar '(lambda (env)
- (ebib-execute-helper env))
- (car form))))
- (cdr form)))
- forms)))
-
-;; the numeric prefix argument is 1 if the user gave no prefix argument at
-;; all. the raw prefix argument is not always a number. so we need to do
-;; our own conversion.
-(defun ebib-prefix (num)
- (when (numberp num)
- num))
-
-(defmacro last1 (lst &optional n)
- "Returns the last (or Nth last) element of LST."
- `(car (last ,lst ,n)))
-
-;; we sometimes need to walk through lists. these functions yield the
-;; element directly preceding or following ELEM in LIST. in order to work
-;; properly, ELEM must be unique in LIST, obviously. if ELEM is the
-;; first/last element of LIST, or if it is not contained in LIST at all,
-;; the result is nil.
-(defun next-elem (elem list)
- (cadr (member elem list)))
-
-(defun prev-elem (elem list)
- (if (or (equal elem (car list))
- (not (member elem list)))
- nil
- (last1 list (1+ (length (member elem list))))))
-
-(defun disabled ()
- (interactive)
- "Does nothing except beep. Used to disable C-x k and C-x b"
- (beep))
-
-(defun read-string-at-point (chars)
- "Reads a string at POINT delimited by CHARS and returns it.
-
-CHARS is a string of characters that should not occur in the string."
- (save-excursion
- (skip-chars-backward (concat "^" chars))
- (let ((beg (point)))
- (looking-at-goto-end (concat "[^" chars "]*"))
- (buffer-substring-no-properties beg (point)))))
-
-(defun ebib-get-obl-fields (entry-type)
- "Returns the obligatory fields of ENTRY-TYPE."
- (car (gethash entry-type ebib-entry-types-hash)))
-
-(defun ebib-get-opt-fields (entry-type)
- "Returns the optional fields of ENTRY-TYPE."
- (cadr (gethash entry-type ebib-entry-types-hash)))
-
-(defun ebib-get-all-fields (entry-type)
- "Returns all the fields of ENTRY-TYPE."
- (cons 'type* (append (ebib-get-obl-fields entry-type)
- (ebib-get-opt-fields entry-type)
- ebib-additional-fields)))
-
-(defun remove-from-string (string remove)
- "Returns a copy of STRING with all the occurrences of REMOVE taken out.
-
-REMOVE can be a regex."
- (apply 'concat (split-string string remove)))
-
-(defun in-string (char string)
- "Returns T if CHAR is in STRING, otherwise NIL."
- (catch 'found
- (do ((len (length string))
- (i 0 (1+ i)))
- ((= i len) nil)
- (if (eq char (aref string i))
- (throw 'found t)))))
-
-(defun ensure-extension (string ext)
- "Makes sure STRING has the extension EXT, by appending it if necessary.
-
-EXT should be an extension without the dot."
- (if (string-match (concat "\\." ext "$") string)
- string
- (concat string "." ext)))
-
-(defmacro with-buffer-writable (&rest body)
- "Makes the current buffer writable and executes the commands in BODY.
-After BODY is executed, the buffer modified flag is unset."
- (declare (indent defun))
- `(unwind-protect
- (let ((buffer-read-only nil))
- ,@body)
- (set-buffer-modified-p nil)))
-
-(defmacro safe-write-region (start end filename &optional append visit lockname mustbenew)
- "XEmacs does not have the MUSTBENEW argument, so this is a way to implement it."
- (if (featurep 'xemacs)
- `(if (and (file-exists-p ,filename)
- (not (y-or-n-p (format "File %s already exists; overwrite anyway? " ,filename))))
- (error "File %s exist" ,filename)
- (write-region ,start ,end ,filename ,append ,visit ,lockname))
- `(write-region ,start ,end ,filename ,append ,visit ,lockname ,mustbenew)))
-
-(defun ebib-erase-buffer (buffer)
- (set-buffer buffer)
- (with-buffer-writable
- (erase-buffer)))
-
-(defun symbol-or-string (x)
- "Returns the symbol-name of X if X is a symbol, otherwise return X.
-
-Much like SYMBOL-NAME, except it does not throw an error if X is not a
-symbol."
- (if (symbolp x)
- (symbol-name x)
- x))
-
-(defun region-active ()
- (if (featurep 'xemacs)
- (region-active-p)
- mark-active))
-
-;; RAW-P determines if STRING is raw. note that we cannot do this by
-;; simply checking whether STRING begins with { and ends with } (or
-;; begins and ends with "), because something like "{abc} # D # {efg}"
-;; would then be incorrectly recognised as non-raw. so we need to do
-;; the following: take out everything that is between braces or
-;; quotes, and see if anything is left. if there is, the original
-;; string was raw, otherwise it was not.
-;;
-;; so i first check whether the string begins with { or ". if not, we
-;; certainly have a raw string. (RAW-P recognises this through the default
-;; clause of the COND.) if the first character is { or ", we first take out
-;; every occurrence of backslash-escaped { and } or ", so that the rest of
-;; the function does not get confused over them.
-;;
-;; then, if the first character is {, i use REMOVE-FROM-STRING to take out
-;; every occurrence of the regex "{[^{]*?}", which translates to "the
-;; smallest string that starts with { and ends with }, and does not contain
-;; another {. IOW, it takes out the innermost braces and their
-;; contents. because braces may be embedded, we have to repeat this step
-;; until no more balanced braces are found in the string. (note that it
-;; would be unwise to check for just the occurrence of { or }, because that
-;; would throw RAW-P in an infinite loop if a string contains an unbalanced
-;; brace.)
-;;
-;; for strings beginning with " i do the same, except that it is not
-;; necessary to repeat this in a WHILE loop, for the simple reason that
-;; strings surrounded with double quotes cannot be embedded; i.e.,
-;; "ab"cd"ef" is not a valid (BibTeX) string, while {ab{cd}ef} is.
-;;
-;; note: because these strings are to be fed to BibTeX and ultimately
-;; (La)TeX, it might seem that we don't need to worry about strings
-;; containing unbalanced braces, because (La)TeX would choke on them. but
-;; the user may inadvertently enter such a string, and we therefore need to
-;; be able to handle it. (alternatively, we could perform a check on
-;; strings and warn the user.)
-
-(defun raw-p (string)
- "Non-nil if STRING is raw."
- (when (stringp string)
- (cond
- ((eq (string-to-char string) ?\{)
- ;; we remove all occurrences of `\{' and of `\}' from the string:
- (let ((clear-str (remove-from-string (remove-from-string string "[\\][{]")
- "[\\][}]")))
- (while (and (in-string ?\{ clear-str) (in-string ?\} clear-str))
- (setq clear-str (remove-from-string clear-str "{[^{]*?}")))
- (> (length clear-str) 0)))
- ((eq (string-to-char string) ?\")
- (let ((clear-str (remove-from-string string "[\\][\"]"))) ; remove occurrences of `\"'
- (setq clear-str (remove-from-string clear-str "\".*?\""))
- (> (length clear-str) 0)))
- (t t))))
-
-(defun to-raw (string)
- "Converts a string to its raw counterpart."
- (if (and (stringp string)
- (not (raw-p string)))
- (substring string 1 -1)
- string))
-
-(defun from-raw (string)
- "Converts a raw string to a non-raw one."
- (if (raw-p string)
- (concat "{" string "}")
- string))
-
-(defun multiline-p (string)
- "True if STRING is multiline."
- (if (stringp string)
- (string-match "\n" string)))
-
-(defun first-line (string)
- "Returns the first line of a multi-line string."
- (string-match "\n" string)
- (substring string 0 (match-beginning 0)))
-
-(defun sort-in-buffer (limit str)
- "Moves POINT to the right position to insert STR in a buffer with lines sorted A-Z."
- (let ((upper limit)
- middle)
- (when (> limit 0)
- (let ((lower 0))
- (goto-char (point-min))
- (while (progn
- (setq middle (/ (+ lower upper 1) 2))
- (goto-line middle) ; if this turns out to be where we need to be,
- (beginning-of-line) ; this puts POINT at the right spot.
- (> (- upper lower) 1)) ; if upper and lower differ by only 1, we have found the
- ; position to insert the entry in.
- (save-excursion
- (let ((beg (point)))
- (end-of-line)
- (if (string< (buffer-substring-no-properties beg (point)) str)
- (setq lower middle)
- (setq upper middle)))))))))
-
-(defun ebib-make-highlight (begin end buffer)
- (let (highlight)
- (if (featurep 'xemacs)
- (progn
- (setq highlight (make-extent begin end buffer))
- (set-extent-face highlight 'highlight))
- (progn
- (setq highlight (make-overlay begin end buffer))
- (overlay-put highlight 'face 'highlight)))
- highlight))
-
-(defun ebib-move-highlight (highlight begin end buffer)
- (if (featurep 'xemacs)
- (set-extent-endpoints highlight begin end buffer)
- (move-overlay highlight begin end buffer)))
-
-(defun ebib-highlight-start (highlight)
- (if (featurep 'xemacs)
- (extent-start-position highlight)
- (overlay-start highlight)))
-
-(defun ebib-highlight-end (highlight)
- (if (featurep 'xemacs)
- (extent-end-position highlight)
- (overlay-end highlight)))
-
-(defun ebib-delete-highlight (highlight)
- (if (featurep 'xemacs)
- (detach-extent highlight)
- (delete-overlay highlight)))
-
-(defun ebib-set-index-highlight ()
- (set-buffer ebib-index-buffer)
- (beginning-of-line)
- (let ((beg (point)))
- (end-of-line)
- (ebib-move-highlight ebib-index-highlight beg (point) ebib-index-buffer)))
-
-(defun ebib-set-fields-highlight ()
- (set-buffer ebib-entry-buffer)
- (beginning-of-line)
- (let ((beg (point)))
- (looking-at-goto-end "[^ \t\n\f]*")
- (ebib-move-highlight ebib-fields-highlight beg (point) ebib-entry-buffer)))
-
-(defun ebib-set-strings-highlight ()
- (set-buffer ebib-strings-buffer)
- (beginning-of-line)
- (let ((beg (point)))
- (looking-at-goto-end "[^ \t\n\f]*")
- (ebib-move-highlight ebib-strings-highlight beg (point) ebib-strings-buffer)))
-
-(defun ebib-redisplay-current-field ()
- "Redisplays the contents of the current field in the entry buffer."
- (set-buffer ebib-entry-buffer)
- (with-buffer-writable
- (goto-char (ebib-highlight-start ebib-fields-highlight))
- (let ((beg (point)))
- (end-of-line)
- (delete-region beg (point)))
- (insert (format "%-17s " (symbol-name ebib-current-field))
- (ebib-get-field-highlighted ebib-current-field ebib-cur-entry-hash))
- (ebib-set-fields-highlight)))
-
-(defun ebib-redisplay-current-string ()
- "Redisplays the current string definition in the strings buffer."
- (set-buffer ebib-strings-buffer)
- (with-buffer-writable
- (let ((str (to-raw (gethash ebib-current-string (edb-strings ebib-cur-db)))))
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (let ((beg (point)))
- (end-of-line)
- (delete-region beg (point)))
- (insert (format "%-18s %s" ebib-current-string
- (if (multiline-p str)
- (concat "+" (first-line str))
- (concat " " str))))
- (ebib-set-strings-highlight))))
-
-(defun ebib-move-to-field (field direction)
- "Moves the fields overlay to the line containing FIELD.
-
-If DIRECTION is positive, searches forward, if DIRECTION is
-negative, searches backward. If DIRECTION is 1 or -1, searches
-from POINT, if DIRECTION is 2 or -2, searches from beginning or
-end of buffer. If FIELD is not found in the entry buffer, the
-overlay is not moved. FIELD must be a symbol."
-
- ;;Note: this function does NOT change the value of EBIB-CURRENT-FIELD!
-
- (set-buffer ebib-entry-buffer)
- (if (eq field 'type*)
- (goto-char (point-min))
- (multiple-value-bind (fn start limit) (if (>= direction 0)
- (values 're-search-forward (point-min) (point-max))
- (values 're-search-backward (point-max) (point-min)))
- ;; make sure we can get back to our original position, if the field
- ;; cannot be found in the buffer:
- (let ((current-pos (point)))
- (when (evenp direction)
- (goto-char start))
- (unless (funcall fn (concat "^" (symbol-name field)) limit t)
- (goto-char current-pos)))))
- (ebib-set-fields-highlight))
-
-(defun looking-at-goto-end (str &optional match)
- "Like LOOKING-AT but moves point to the end of the matching string.
-
-MATCH acts just like the argument to MATCH-END, and defaults to 0."
- (or match (setq match 0))
- (let ((case-fold-search t))
- (if (looking-at str)
- (goto-char (match-end match)))))
-
-(defun ebib-create-collection (hashtable)
- "Creates a list from the keys in HASHTABLE that can be used as COLLECTION in COMPLETING-READ.
-
-The keys of HASHTABLE must be either symbols or strings."
- (let ((result nil))
- (maphash '(lambda (x y)
- (setq result (cons (cons (symbol-or-string x)
- 0)
- result)))
- hashtable)
- result))
-
-(defun match-all (match-str string)
- "Highlights all the matches of MATCH-STR in STRING.
-
-The return value is a list of two elements: the first is the modified
-string, the second either t or nil, indicating whether a match was found at
-all."
- (do ((counter 0 (match-end 0)))
- ((not (string-match match-str string counter)) (values string (not (= counter 0))))
- (add-text-properties (match-beginning 0) (match-end 0) '(face highlight) string)))
-
-(defun ebib-get-field-highlighted (field current-entry &optional match-str)
- ;; note: we need to work on a copy of the string, otherwise the highlights
- ;; are made to the string as stored in the database. hence copy-sequence.
- (let ((case-fold-search t)
- (string (copy-sequence (gethash field current-entry)))
- (raw " ")
- (multiline " ")
- (matched nil))
- ;; we have to do a couple of things now:
- ;; - remove {} or "" around the string, if they're there
- ;; - search for match-str
- ;; - properly adjust the string if it's multiline
- ;; but all this is not necessary if there was no string
- (if (null string)
- (setq string "")
- (if (raw-p string)
- (setq raw "*")
- (setq string (to-raw string))) ; we have to make the string look nice
- (when match-str
- (multiple-value-setq (string matched) (match-all match-str string)))
- (when (multiline-p string)
- ;; IIUC COPY-SEQUENCE shouldn't be necessary here, as the variable
- ;; multiline is local and therefore the object it refers to should
- ;; be GC'ed when the function returns. but for some reason, the
- ;; plus sign is persistent, and if it's been highlighted as the
- ;; result of a search, it stays that way.
- (setq multiline (copy-sequence "+")) ; (propertize "+" nil nil))
- (setq string (first-line string))))
- (when (and matched
- (string= multiline "+"))
- (add-text-properties 0 1 '(face highlight) multiline))
- (concat raw multiline string)))
-
-(defun ebib-format-fields (entry fn &optional match-str)
- (let* ((entry-type (gethash 'type* entry))
- (obl-fields (ebib-get-obl-fields entry-type))
- (opt-fields (ebib-get-opt-fields entry-type)))
- (funcall fn (format "%-19s %s\n" "type" entry-type))
- (mapc '(lambda (fields)
- (funcall fn "\n")
- (mapcar '(lambda (field)
- (unless (and (get field 'ebib-hidden)
- ebib-hide-hidden-fields)
- (funcall fn (format "%-17s " field))
- (funcall fn (or
- (ebib-get-field-highlighted field entry match-str)
- ""))
- (funcall fn "\n")))
- fields))
- (list obl-fields opt-fields ebib-additional-fields))))
-
-(defun ebib-fill-entry-buffer (&optional match-str)
- "Fills the entry buffer with the fields of the current entry.
-
-MATCH-STRING is a regexp that will be highlighted when it occurs in the
-field contents."
- (set-buffer ebib-entry-buffer)
- (with-buffer-writable
- (erase-buffer)
- (when (and ebib-cur-db ; do we have a database?
- (edb-keys-list ebib-cur-db) ; does it contain entries?
- (gethash (car (edb-cur-entry ebib-cur-db))
- (edb-database ebib-cur-db))) ; does the current entry exist?
- (ebib-format-fields (gethash (car (edb-cur-entry ebib-cur-db))
- (edb-database ebib-cur-db)) 'insert match-str)
- (setq ebib-current-field 'type*)
- (goto-char (point-min))
- (ebib-set-fields-highlight))))
-
-(defun ebib-set-modified (mod &optional db)
- "Sets the modified flag of the database DB to MOD.
-
-If DB is nil, it defaults to the current database, and the modified flag of
-the index buffer is also (re)set. MOD must be either T or NIL."
- (unless db
- (setq db ebib-cur-db))
- (setf (edb-modified db) mod)
- (when (eq db ebib-cur-db)
- (save-excursion
- (set-buffer ebib-index-buffer)
- (set-buffer-modified-p mod))))
-
-(defun ebib-modified-p ()
- "Checks if any of the databases in Ebib were modified.
-
-Returns the first modified database, or NIL if none was modified."
- (let ((db (car ebib-databases)))
- (while (and db
- (not (edb-modified db)))
- (setq db (next-elem db ebib-databases)))
- db))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; main program execution ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defun ebib ()
- "Ebib, a BibTeX database manager."
- (interactive)
- (if (or (equal (window-buffer) ebib-index-buffer)
- (equal (window-buffer) ebib-entry-buffer))
- (error "Ebib already active")
- (unless ebib-initialized
- (ebib-init)
- (if ebib-preload-bib-files
- (mapc '(lambda (file)
- (ebib-load-bibtex-file file))
- ebib-preload-bib-files)))
- ;; we save the current window configuration.
- (setq ebib-saved-window-config (current-window-configuration))
- ;; create the window configuration we want for ebib.
- (delete-other-windows)
- (switch-to-buffer ebib-index-buffer)
- (let* ((keys-window (selected-window))
- (entry-window (split-window keys-window ebib-index-window-size)))
- (set-window-buffer entry-window ebib-entry-buffer))))
-
-(defun ebib-create-buffers ()
- "Creates the buffers for Ebib."
- ;; first we create a buffer for multiline editing. this one does *not*
- ;; have a name beginning with a space, because undo-info is normally
- ;; present in an edit buffer.
- (setq ebib-multiline-buffer (get-buffer-create "*Ebib-edit*"))
- (set-buffer ebib-multiline-buffer)
- (ebib-multiline-edit-mode)
- ;; then we create a buffer to hold the fields of the current entry.
- (setq ebib-entry-buffer (get-buffer-create " *Ebib-entry*"))
- (set-buffer ebib-entry-buffer)
- (ebib-entry-mode)
- ;; then we create a buffer to hold the @STRING definitions
- (setq ebib-strings-buffer (get-buffer-create " *Ebib-strings*"))
- (set-buffer ebib-strings-buffer)
- (ebib-strings-mode)
- ;; then we create the help buffer
- (setq ebib-help-buffer (get-buffer-create " *Ebib-help*"))
- (set-buffer ebib-help-buffer)
- (ebib-help-mode)
- ;; and lastly we create a buffer for the entry keys.
- (setq ebib-index-buffer (get-buffer-create " none"))
- (set-buffer ebib-index-buffer)
- (ebib-index-mode))
-
-(defun ebib-init ()
- "Initialises Ebib.
-
-This function sets all variables to their initial values, creates the
-buffers and reads the rc file."
- (setq ebib-cur-entry-hash nil
- ebib-current-field nil
- ebib-minibuf-hist nil
- ebib-saved-window-config nil)
- (put 'timestamp 'ebib-hidden t)
- (when (file-readable-p "~/.ebibrc")
- (load "~/.ebibrc"))
- (ebib-create-buffers)
- (setq ebib-index-highlight (ebib-make-highlight 1 1 ebib-index-buffer))
- (setq ebib-fields-highlight (ebib-make-highlight 1 1 ebib-entry-buffer))
- (setq ebib-strings-highlight (ebib-make-highlight 1 1 ebib-strings-buffer))
- (setq ebib-initialized t))
-
-(defun ebib-create-new-database (&optional db)
- "Creates a new database instance and returns it.
-
-If DB is set to a database, the new database is a copy of DB."
- (let ((new-db
- (if (edb-p db)
- (copy-edb db)
- (make-edb))))
- (setq ebib-databases (append ebib-databases (list new-db)))
- new-db))
-
-(defun ebib-quit ()
- "Quits Ebib.
-
-The Ebib buffers are killed, all variables except the keymaps are set to nil."
- (interactive)
- (when (if (ebib-modified-p)
- (yes-or-no-p "There are modified databases. Quit anyway? ")
- (y-or-n-p "Quit Ebib? "))
- (kill-buffer ebib-entry-buffer)
- (kill-buffer ebib-index-buffer)
- (kill-buffer ebib-multiline-buffer)
- (setq ebib-databases nil
- ebib-index-buffer nil
- ebib-entry-buffer nil
- ebib-initialized nil
- ebib-index-highlight nil
- ebib-fields-highlight nil
- ebib-strings-highlight nil
- ebib-export-filename nil)
- (set-window-configuration ebib-saved-window-config)
- (message "")))
-
-(defun ebib-kill-emacs-query-function ()
- "Ask if the user wants to save the database loaded in Ebib when Emacs is
-killed and the database has been modified."
- (if (not (ebib-modified-p))
- t
- (if (y-or-n-p "Save all unsaved Ebib databases? ")
- (progn
- (ebib-save-all-databases)
- t)
- (yes-or-no-p "Ebib database was modified. Kill anyway? "))))
-
-(add-hook 'kill-emacs-query-functions 'ebib-kill-emacs-query-function)
-
-;; the next two functions are used in loading the database. a database is
-;; loaded by reading the raw file into a temp buffer and then reading all
-;; the entries in it. for this we need to be able to search a matching
-;; parenthesis and a matching double quote.
-
-(defun ebib-match-paren-forward (limit)
- "Moves forward to the closing parenthesis matching the opening parenthesis at POINT.
-
-Does not search/move beyond LIMIT. Returns T if a matching parenthesis was
-found, NIL otherwise. If point was not at an opening parenthesis at all,
-NIL is returned and point is not moved. If point was at an opening
-parenthesis but no matching closing parenthesis was found, point is moved
-to LIMIT."
- (if (nor (eq (char-after) ?\{)
- (eq (char-after) ?\"))
- nil
- (save-restriction
- (narrow-to-region (point-min) limit)
- (condition-case nil
- (progn
- (forward-list)
- ;; all of ebib expects that point moves to the closing
- ;; parenthesis, not right after it, so we adjust.
- (forward-char -1)
- t) ; return t because a matching brace was found
- (error (progn
- (goto-char (point-max)) ; point-max because the narrowing is still in effect
- nil))))))
-
-(defun ebib-match-quote-forward (limit)
- "Moves to the closing double quote matching the quote at POINT.
-
-Does not search/move beyond LIMIT. Returns T if a matching quote was found,
-NIL otherwise. If point was not at a double quote at all, NIL is returned
-and point is not moved. If point was at a quote but no matching closing
-quote was found, point is moved to LIMIT."
- (when (eq (char-after (point)) ?\") ; make sure we're on a double quote.
- (while
- (progn
- (forward-char) ; we need to move forward because we're on a double quote.
- (skip-chars-forward "^\"" limit) ; find the next double quote.
- (and (eq (char-before) ?\\) ; if it's preceded by a backslash,
- (< (point) limit)))) ; and we're still below LIMIT, keep on searching.
- (eq (char-after (point)) ?\"))) ; return T or NIL based on whether we've found a quote.
-
-(defun ebib-insert-entry (entry-key fields db &optional sort timestamp)
- "Stores the entry defined by ENTRY-KEY and FIELDS into DB.
-
-Optional argument SORT indicates whether the KEYS-LIST must be
-sorted after insertion. Default is NIL. Optional argument
-TIMESTAMP indicates whether a timestamp is to be added to the
-entry. Note that for a timestamp to be added, EBIB-USE-TIMESTAMP
-must also be set to T."
- (when (and timestamp ebib-use-timestamp)
- (puthash 'timestamp (from-raw (format-time-string ebib-timestamp-format)) fields))
- (puthash entry-key fields (edb-database db))
- (ebib-set-modified t db)
- (setf (edb-n-entries db) (1+ (edb-n-entries db)))
- (setf (edb-keys-list db)
- (if sort
- (sort (cons entry-key (edb-keys-list db)) 'string<)
- (cons entry-key (edb-keys-list db)))))
-
-(defun ebib-insert-string (abbr string db &optional sort)
- "Stores the @STRING definition defined by ABBR and STRING into DB.
-
-Optional argument SORT indicates whether the STRINGS-LIST must be sorted
-after insertion. When loading or merging a file, for example, it is more
-economic to sort KEYS-LIST manually after all entries in the file have been
-added."
- (puthash abbr (from-raw string) (edb-strings db))
- (ebib-set-modified t db)
- (setf (edb-strings-list db)
- (if sort
- (sort (cons abbr (edb-strings-list db)) 'string<)
- (cons abbr (edb-strings-list db)))))
-
-(defmacro ebib-retrieve-entry (entry-key db)
- "Returns the hash table of the fields stored in DB under ENTRY-KEY."
- `(gethash ,entry-key (edb-database ,db)))
-
-(defmacro ebib-cur-entry-key ()
- "Returns the key of the current entry in EBIB-CUR-DB."
- `(car (edb-cur-entry ebib-cur-db)))
-
-(defun ebib-search-key-in-buffer (entry-key)
- "Searches ENTRY-KEY in the index buffer.
-
-Moves point to the first character of the key and returns point."
- (goto-char (point-min))
- (search-forward entry-key)
- (beginning-of-line)
- (point))
-
-;; when we sort entries, we either use string< on the entry keys, or
-;; ebib-entry<, if the user has defined a sort order.
-
-(defun ebib-entry< (x y)
- "Returns T if entry X is smaller than entry Y.
-
-The entries are compared based on the fields listed in EBIB-SORT-ORDER. X
-and Y should be keys of entries in the current database."
- (let* ((sort-list ebib-sort-order)
- (sortstring-x (to-raw (ebib-get-sortstring x (car sort-list))))
- (sortstring-y (to-raw (ebib-get-sortstring y (car sort-list)))))
- (while (and sort-list
- (string= sortstring-x sortstring-y))
- (setq sort-list (cdr sort-list))
- (setq sortstring-x (to-raw (ebib-get-sortstring x (car sort-list))))
- (setq sortstring-y (to-raw (ebib-get-sortstring y (car sort-list)))))
- (if (and sortstring-x sortstring-y)
- (string< sortstring-x sortstring-y)
- (string< x y))))
-
-(defun ebib-get-sortstring (entry-key sortkey-list)
- "Returns the field value on which the entry ENTRY-KEY is to be sorted.
-
-ENTRY-KEY must be the key of an entry in the current database. SORTKEY-LIST
-is a list of fields that are considered in order for the sort value."
- (let ((sort-string nil))
- (while (and sortkey-list
- (null (setq sort-string (gethash (car sortkey-list)
- (ebib-retrieve-entry entry-key ebib-cur-db)))))
- (setq sortkey-list (cdr sortkey-list)))
- sort-string))
-
-;;;;;;;;;;;;;;;
-;; index-mode ;;
-;;;;;;;;;;;;;;;
-
-(defvar ebib-index-mode-map
- (let ((map (make-keymap 'ebib-index-mode-map)))
- (suppress-keymap map)
- (define-key map [up] 'ebib-prev-entry)
- (define-key map [down] 'ebib-next-entry)
- (define-key map [right] 'ebib-next-database)
- (define-key map [left] 'ebib-prev-database)
- (define-key map [home] 'ebib-goto-first-entry)
- (define-key map [end] 'ebib-goto-last-entry)
- (define-key map [prior] 'ebib-index-scroll-down)
- (define-key map [next] 'ebib-index-scroll-up)
- (define-key map [return] 'ebib-select-entry)
- (define-key map " " 'ebib-index-scroll-up)
- (define-key map "a" 'ebib-add-entry)
- (define-key map "b" 'ebib-index-scroll-down)
- (define-key map "c" 'ebib-close-database)
- (define-key map "C" 'ebib-customize)
- (define-key map "d" 'ebib-delete-entry)
- (define-key map "e" 'ebib-edit-entry)
- (define-key map "E" 'ebib-edit-keyname)
- (define-key map "f" 'ebib-print-filename)
- (define-key map "F" 'ebib-follow-crossref)
- (define-key map "g" 'ebib-goto-first-entry)
- (define-key map "G" 'ebib-goto-last-entry)
- (define-key map "h" 'ebib-index-help)
- (define-key map "H" 'ebib-toggle-hidden)
- (define-key map "j" 'ebib-next-entry)
- (define-key map "J" 'ebib-switch-to-database)
- (define-key map "k" 'ebib-prev-entry)
- (define-key map "L" 'ebib-latex-database)
- (define-key map "M" 'ebib-merge-bibtex-file)
- (define-key map "n" 'ebib-search-next)
- (define-key map "o" 'ebib-load-bibtex-file)
- (define-key map "p" 'ebib-edit-preamble)
- (define-key map "P" 'ebib-print-database)
- (define-key map "q" 'ebib-quit)
- (define-key map "s" 'ebib-save-current-database)
- (define-key map "S" 'ebib-save-all-databases)
- (define-key map "t" 'ebib-edit-strings)
- (define-key map "V" 'ebib-print-filter)
- (define-key map "w" 'ebib-write-database)
- (define-key map "x" 'ebib-export-entry)
- (define-key map "X" 'ebib-export-preamble)
- (define-key map "z" 'ebib-lower)
- (define-key map "/" 'ebib-search)
- (define-key map "&" 'ebib-virtual-db-and)
- (define-key map "|" 'ebib-virtual-db-or)
- (define-key map "~" 'ebib-virtual-db-not)
- (define-key map [(control n)] 'ebib-next-entry)
- (define-key map [(meta n)] 'ebib-index-scroll-up)
- (define-key map [(control p)] 'ebib-prev-entry)
- (define-key map [(meta p)] 'ebib-index-scroll-down)
- (define-key map "\C-xb" 'ebib-lower)
- (define-key map "\C-xk" 'ebib-quit)
- map)
- "Keymap for the ebib index buffer.")
-
-(defun ebib-switch-to-database-nth (key)
- (interactive (list (if (featurep 'xemacs)
- (event-key last-command-event)
- last-command-event)))
- (ebib-switch-to-database (- (if (featurep 'xemacs)
- (char-to-int key)
- key) 48)))
-
-(mapc #'(lambda (key)
- (define-key ebib-index-mode-map (format "%d" key)
- 'ebib-switch-to-database-nth))
- '(1 2 3 4 5 6 7 8 9))
-
-(define-derived-mode ebib-index-mode
- fundamental-mode "Ebib-index"
- "Major mode for the Ebib index buffer."
- (setq buffer-read-only t))
-
-(defun ebib-fill-index-buffer ()
- "Fills the index buffer with the list of keys in EBIB-CUR-DB.
-
-If EBIB-CUR-DB is nil, the buffer is just erased and its name set to \"none\"."
- (set-buffer ebib-index-buffer)
- (let ((buffer-read-only nil))
- (erase-buffer)
- (if ebib-cur-db
- (progn
- ;; we may call this function when there are no entries in the
- ;; database. if so, we don't need to do this:
- (when (edb-cur-entry ebib-cur-db)
- ;; the two inserts look funny, but we cannot use format here
- ;; because in xemacs, format does not retain text properties.
- (mapcar '(lambda (x) (insert x) (insert "\n")) (edb-keys-list ebib-cur-db))
- (goto-char (point-min))
- (re-search-forward (format "^%s$" (ebib-cur-entry-key)))
- (beginning-of-line)
- (ebib-set-index-highlight))
- (set-buffer-modified-p (edb-modified ebib-cur-db))
- (rename-buffer (concat (format " %d:" (1+ (- (length ebib-databases)
- (length (member ebib-cur-db ebib-databases)))))
- (edb-name ebib-cur-db))))
- (rename-buffer " none"))))
-
-(defun ebib-customize ()
- (interactive)
- (ebib-lower)
- (customize-group 'ebib))
-
-(defun ebib-load-bibtex-file (&optional file)
- "Loads a BibTeX file into ebib."
- (interactive)
- (unless file
- (setq file (ensure-extension (read-file-name "File to open: " "~/") "bib")))
- (setq ebib-cur-db (ebib-create-new-database))
- (setf (edb-filename ebib-cur-db) (expand-file-name file))
- (setf (edb-name ebib-cur-db) (file-name-nondirectory (edb-filename ebib-cur-db)))
- ;; first, we empty the buffers
- (ebib-erase-buffer ebib-index-buffer)
- (ebib-erase-buffer ebib-entry-buffer)
- (if (file-readable-p file)
- ;; if the user entered the name of an existing file, we load it
- ;; by putting it in a buffer and then parsing it.
- (with-temp-buffer
- (insert-file-contents file)
- ;; if the user makes any changes, we'll want to create a back-up.
- (setf (edb-make-backup ebib-cur-db) t)
- (let ((result (ebib-find-bibtex-entries nil)))
- (setf (edb-n-entries ebib-cur-db) (car result))
- (when (edb-keys-list ebib-cur-db)
- (setf (edb-keys-list ebib-cur-db) (sort (edb-keys-list ebib-cur-db) 'string<)))
- (when (edb-strings-list ebib-cur-db)
- (setf (edb-strings-list ebib-cur-db) (sort (edb-strings-list ebib-cur-db) 'string<)))
- (setf (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db))
- ;; and fill the buffers. note that filling a buffer also makes
- ;; that buffer active. therefore we do EBIB-FILL-INDEX-BUFFER
- ;; later.
- (ebib-set-modified nil)
- (ebib-fill-entry-buffer)
- ;; and now we tell the user the result
- (message "%d entries, %d @STRINGs and %s @PREAMBLE found in file."
- (car result)
- (cadr result)
- (if (caddr result)
- "a"
- "no"))))
- ;; if the file does not exist, we need to issue a message.
- (message "(New file)"))
- ;; what we have to do in *any* case, is fill the index buffer. (this
- ;; even works if there are no keys in the database, e.g. when the
- ;; user opened a new file or if no BibTeX entries were found.
- (ebib-fill-index-buffer))
-
-(defun ebib-merge-bibtex-file ()
- "Merges a BibTeX file into the database."
- (interactive)
- (unless (edb-virtual ebib-cur-db)
- (if (not ebib-cur-db)
- (error "No database loaded. Use `o' to open a database")
- (let ((file (read-file-name "File to merge: ")))
- (with-temp-buffer
- (insert-file-contents file)
- (let ((n (ebib-find-bibtex-entries t)))
- (setf (edb-keys-list ebib-cur-db) (sort (edb-keys-list ebib-cur-db) 'string<))
- (setf (edb-n-entries ebib-cur-db) (length (edb-keys-list ebib-cur-db)))
- (when (edb-strings-list ebib-cur-db)
- (setf (edb-strings-list ebib-cur-db) (sort (edb-strings-list ebib-cur-db) 'string<)))
- (setf (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db))
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer)
- (ebib-set-modified t)
- (message "%d entries, %d @STRINGs and %s @PREAMBLE found in file."
- (car n)
- (cadr n)
- (if (caddr n)
- "a"
- "no"))))))))
-
-(defun ebib-find-bibtex-entries (timestamp)
- "Finds the BibTeX entries in the current buffer.
-
-The search is started at the beginnig of the buffer. All entries found are
-stored in the hash table DATABASE of EBIB-CUR-DB. Returns a three-element
-list: the first element is the number of entries found, the second the
-number of @STRING definitions, and the third is T or NIL, indicating
-whether a @PREAMBLE was found.
-
-TIMESTAMP indicates whether a timestamp is to be added to each
-entry. Note that a timestamp is only added if EBIB-USE-TIMESTAMP
-is set to T."
- (modify-syntax-entry ?\" "w")
- (let ((n-entries 0)
- (n-strings 0)
- (preamble nil))
- (goto-char (point-min))
- (while (re-search-forward "^@" nil t) ; find the next entry
- (let ((beg (point)))
- (when (looking-at-goto-end (concat ebib-bibtex-identifier "[\(\{]"))
- (let ((entry-type (downcase (buffer-substring-no-properties beg (1- (point))))))
- (cond
- ((equal entry-type "string") ; string and preamble must be treated differently
- (if (ebib-read-string)
- (setq n-strings (1+ n-strings))))
- ((equal entry-type "preamble") (ebib-read-preamble)
- (setq preamble t))
- ((equal entry-type "comment") (ebib-match-paren-forward (point-max))) ; ignore comments
- ((gethash (intern-soft entry-type) ebib-entry-types-hash) ; if the entry type has been defined
- (if (ebib-read-entry entry-type timestamp)
- (setq n-entries (1+ n-entries))))
- (t (message "Unknown entry type `%s'. Skipping." entry-type) ; we found something we don't know
- (ebib-match-paren-forward (point-max))))))))
- (list n-entries n-strings preamble)))
-
-(defun ebib-read-string ()
- "Reads the @STRING definition beginning at the line POINT is on.
-
-If a proper abbreviation and string are found, they are stored in the
-database. Returns the string if one was read, nil otherwise."
- (let ((limit (save-excursion ; we find the matching end parenthesis
- (backward-char)
- (ebib-match-paren-forward (point-max))
- (point))))
- (skip-chars-forward "\"#%'(),={} \n\t\f" limit)
- (let ((beg (point)))
- (when (looking-at-goto-end (concat "\\(" ebib-bibtex-identifier "\\)[ \t\n\f]*=") 1)
- (if-str (abbr (buffer-substring-no-properties beg (point)))
- (progn
- (skip-chars-forward "^\"{" limit)
- (let ((beg (point)))
- (if-str (string (cond
- ((eq (char-after) ?\" ) (if (ebib-match-quote-forward limit)
- (buffer-substring-no-properties beg (1+ (point)))
- nil))
- ((eq (char-after) ?\{ ) (if (ebib-match-paren-forward limit)
- (buffer-substring-no-properties beg (1+ (point)))
- nil))
- (t nil)))
- (if (member abbr (edb-strings-list ebib-cur-db))
- (message (format "@STRING definition `%s' duplicated" abbr))
- (ebib-insert-string abbr string ebib-cur-db))))))))))
-
-(defun ebib-read-preamble ()
- "Reads the @PREAMBLE definition and stores it in EBIB-PREAMBLE.
-
-If there was already another @PREAMBLE definition, the new one is added to
-the existing one with a hash sign `#' between them."
- (let ((beg (point)))
- (forward-char -1)
- (ebib-match-paren-forward (point-max))
- (let ((text (buffer-substring-no-properties beg (point))))
- (if (edb-preamble ebib-cur-db)
- (setf (edb-preamble ebib-cur-db) (concat (edb-preamble ebib-cur-db) "\n# " text))
- (setf (edb-preamble ebib-cur-db) text)))))
-
-(defun ebib-read-entry (entry-type &optional timestamp)
- "Reads a BibTeX entry and stores it in DATABASE of EBIB-CUR-DB.
-
-Returns the new EBIB-KEYS-LIST if an entry was found, nil
-otherwise. Optional argument TIMESTAMP indicates whether a
-timestamp is to be added. (Whether a timestamp is actually added,
-also depends on EBIB-USE-TIMESTAMP.)"
- (let ((entry-limit (save-excursion
- (backward-char)
- (ebib-match-paren-forward (point-max))
- (point)))
- (beg (progn
- (skip-chars-forward " \n\t\f") ; note the space!
- (point))))
- (when (looking-at-goto-end (concat "\\("
- ebib-bibtex-identifier
- "\\)[ \t\n\f]*,")
- 1) ; this delimits the entry key
- (let ((entry-key (buffer-substring-no-properties beg (point))))
- (if (member entry-key (edb-keys-list ebib-cur-db))
- (message "Entry `%s' duplicated " entry-key)
- (let ((fields (ebib-find-bibtex-fields (intern-soft entry-type) entry-limit)))
- (when fields ; if fields were found, we store them, and return T.
- (ebib-insert-entry entry-key fields ebib-cur-db nil timestamp)
- t)))))))
-
-(defun ebib-find-bibtex-fields (entry-type limit)
- "Finds the fields of the BibTeX entry that starts on the line POINT is on.
-
-Returns a hash table containing all the fields and values, or NIL if none
-were found. ENTRY-TYPE is the type of the entry, which will be recorded in
-the hash table. Before the search starts, POINT is moved back to the
-beginning of the line."
- (beginning-of-line)
- (let ((fields (make-hash-table :size 15)))
- (while (progn
- (skip-chars-forward "^," limit) ; we must move to the next comma,
- (eq (char-after) ?,)) ; and make sure we are really on a comma.
- (skip-chars-forward "\"#%'(),={} \n\t\f" limit)
- (let ((beg (point)))
- (when (looking-at-goto-end (concat "\\(" ebib-bibtex-identifier "\\)[ \t\n\f]*=") 1)
- (let ((field-type (intern (downcase (buffer-substring-no-properties beg (point))))))
- (unless (eq field-type 'type*) ; the 'type*' key holds the entry type, so we can't use it
- (let ((field-contents (ebib-get-field-contents limit)))
- (when field-contents
- (puthash field-type field-contents fields))))))))
- (when (> (hash-table-count fields) 0)
- (puthash 'type* entry-type fields)
- fields)))
-
-(defun ebib-get-field-contents (limit)
- "Gets the contents of a BibTeX field.
-
-LIMIT indicates the end of the entry, beyond which the function will not
-search."
- (skip-chars-forward "#%'(),=} \n\t\f" limit)
- (let ((beg (point)))
- (buffer-substring-no-properties beg (ebib-find-end-of-field limit))))
-
-(defun ebib-find-end-of-field (limit)
- "Moves POINT to the end of a field's contents and returns POINT.
-
-The contents of a field is delimited by a comma or by the closing brace of
-the entry. The latter is at position LIMIT."
- (while (and (not (eq (char-after) ?\,))
- (< (point) limit))
- (cond
- ((eq (char-after) ?\{) (ebib-match-paren-forward limit))
- ((eq (char-after) ?\") (ebib-match-quote-forward limit)))
- (forward-char 1))
- (if (= (point) limit)
- (skip-chars-backward " \n\t\f"))
- (point))
-
-(defun ebib-lower ()
- "Hides the Ebib buffers, but does not delete them."
- (interactive)
- (if (nor (equal (window-buffer) ebib-index-buffer)
- (equal (window-buffer) ebib-entry-buffer)
- (equal (window-buffer) ebib-strings-buffer)
- (equal (window-buffer) ebib-multiline-buffer)
- (equal (window-buffer) ebib-help-buffer))
- (error "Ebib is not active ")
- (set-window-configuration ebib-saved-window-config)
- (bury-buffer ebib-entry-buffer)
- (bury-buffer ebib-index-buffer)
- (bury-buffer ebib-multiline-buffer)
- (bury-buffer ebib-strings-buffer)
- (bury-buffer ebib-help-buffer)))
-
-(defun ebib-prev-entry ()
- "Moves to the previous BibTeX entry."
- (interactive)
- (ebib-execute-when
- ((entries)
- ;; if the current entry is the first entry,
- (if (eq (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db))
- (beep) ; just beep.
- (setf (edb-cur-entry ebib-cur-db) (last (edb-keys-list ebib-cur-db)
- (1+ (length (edb-cur-entry ebib-cur-db)))))
- (goto-char (ebib-highlight-start ebib-index-highlight))
- (forward-line -1)
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer)))
- ((default)
- (beep))))
-
-(defun ebib-next-entry ()
- "Moves to the next BibTeX entry."
- (interactive)
- (ebib-execute-when
- ((entries)
- (if (= (length (edb-cur-entry ebib-cur-db)) 1) ; if we're on the last entry,
- (beep) ; just beep.
- (setf (edb-cur-entry ebib-cur-db)
- (last (edb-keys-list ebib-cur-db) (1- (length (edb-cur-entry ebib-cur-db)))))
- (goto-char (ebib-highlight-start ebib-index-highlight))
- (forward-line 1)
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer)))
- ((default)
- (beep))))
-
-(defun ebib-add-entry ()
- "Adds a new entry to the database."
- (interactive)
- (ebib-execute-when
- ((real-db)
- (if-str (entry-key (read-string "New entry key: "))
- (progn
- (if (member entry-key (edb-keys-list ebib-cur-db))
- (error "Key already exists")
- (set-buffer ebib-index-buffer)
- (sort-in-buffer (1+ (edb-n-entries ebib-cur-db)) entry-key)
- (with-buffer-writable
- (insert (format "%s\n" entry-key))) ; add the entry in the buffer.
- (forward-line -1) ; move one line up to position the cursor on the new entry.
- (ebib-set-index-highlight)
- (let ((fields (make-hash-table)))
- (puthash 'type* ebib-default-type fields)
- (ebib-insert-entry entry-key fields ebib-cur-db t t))
- (setf (edb-cur-entry ebib-cur-db) (member entry-key (edb-keys-list ebib-cur-db)))
- (ebib-fill-entry-buffer)
- (ebib-edit-entry)
- (ebib-set-modified t)))))
- ((no-database)
- (error "No database open. Use `o' to open a database first"))
- ((default)
- (beep))))
-
-(defun ebib-close-database ()
- "Closes the current BibTeX database."
- (interactive)
- (ebib-execute-when
- ((database)
- (when (if (edb-modified ebib-cur-db)
- (yes-or-no-p "Database modified. Close it anyway? ")
- (y-or-n-p "Close database? "))
- (let ((to-be-deleted ebib-cur-db)
- (new-db (next-elem ebib-cur-db ebib-databases)))
- (setq ebib-databases (delete to-be-deleted ebib-databases))
- (if ebib-databases ; do we still have another database loaded?
- (progn
- (setq ebib-cur-db (or new-db
- (last1 ebib-databases)))
- (unless (edb-cur-entry ebib-cur-db)
- (setf (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db)))
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer))
- ;; otherwise, we have to clean up a little and empty all the buffers.
- (setq ebib-cur-db nil)
- (mapc #'(lambda (buf) ; this is just to avoid typing almost the same thing three times...
- (set-buffer (car buf))
- (with-buffer-writable
- (erase-buffer))
- (ebib-delete-highlight (cadr buf)))
- (list (list ebib-entry-buffer ebib-fields-highlight)
- (list ebib-index-buffer ebib-index-highlight)
- (list ebib-strings-buffer ebib-strings-highlight)))
- ;; multiline edit buffer
- (set-buffer ebib-multiline-buffer)
- (with-buffer-writable
- (erase-buffer))
- (set-buffer ebib-index-buffer)
- (rename-buffer " none"))
- (message "Database closed."))))))
-
-(defun ebib-goto-first-entry ()
- "Moves to the first BibTeX entry in the database."
- (interactive)
- (ebib-execute-when
- ((entries)
- (setf (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db))
- (set-buffer ebib-index-buffer)
- (goto-char (point-min))
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer))
- ((default)
- (beep))))
-
-(defun ebib-goto-last-entry ()
- "Moves to the last entry in the BibTeX database."
- (interactive)
- (ebib-execute-when
- ((entries)
- (setf (edb-cur-entry ebib-cur-db) (last (edb-keys-list ebib-cur-db)))
- (set-buffer ebib-index-buffer)
- (goto-line (edb-n-entries ebib-cur-db))
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer))
- ((default)
- (beep))))
-
-(defun ebib-edit-entry ()
- "Edits the current BibTeX entry."
- (interactive)
- (ebib-execute-when
- ((real-db entries)
- (setq ebib-cur-entry-hash (ebib-retrieve-entry (ebib-cur-entry-key) ebib-cur-db))
- (setq ebib-cur-entry-fields (ebib-get-all-fields (gethash 'type* ebib-cur-entry-hash)))
- (other-window 1)
- (switch-to-buffer ebib-entry-buffer)
- (goto-char (ebib-highlight-end ebib-fields-highlight)))
- ((default)
- (beep))))
-
-(defun ebib-edit-keyname ()
- "Change the key of a BibTeX entry."
- (interactive)
- (ebib-execute-when
- ((real-db entries)
- (let ((cur-keyname (ebib-cur-entry-key)))
- (if-str (new-keyname (read-string (format "Change `%s' to: " cur-keyname)
- cur-keyname))
- (if (member new-keyname (edb-keys-list ebib-cur-db))
- (error (format "Key `%s' already exists" new-keyname))
- (unless (string= cur-keyname new-keyname)
- (let ((fields (ebib-retrieve-entry cur-keyname ebib-cur-db)))
- (ebib-remove-entry-from-db cur-keyname ebib-cur-db)
- (ebib-remove-key-from-buffer cur-keyname)
- (ebib-insert-entry new-keyname fields ebib-cur-db t nil)
- (setf (edb-cur-entry ebib-cur-db) (member new-keyname (edb-keys-list ebib-cur-db)))
- (sort-in-buffer (edb-n-entries ebib-cur-db) new-keyname)
- (with-buffer-writable
- (insert (format "%s\n" new-keyname))) ; add the entry in the buffer.
- (forward-line -1) ; move one line up to position the cursor on the new entry.
- (ebib-set-index-highlight)
- (ebib-set-modified t)))))))
- ((default)
- (beep))))
-
-(defun ebib-index-scroll-down ()
- "Move one page up in the database."
- (interactive)
- (ebib-execute-when
- ((entries)
- (scroll-down)
- (ebib-select-entry))
- ((default)
- (beep))))
-
-(defun ebib-index-scroll-up ()
- "Move one page down in the database."
- (interactive)
- (ebib-execute-when
- ((entries)
- (scroll-up)
- (ebib-select-entry))
- ((default)
- (beep))))
-
-(defun ebib-format-entry (key db timestamp)
- "Format entry KEY from database DB into the current buffer in BibTeX format.
-
-If TIMESTAMP is T, a timestamp is added to the entry if EBIB-USE-TIMESTAMP is T."
- (let ((entry (ebib-retrieve-entry key db)))
- (when entry
- (insert (format "@%s{%s,\n" (gethash 'type* entry) key))
- (maphash '(lambda (key value)
- (unless (or (eq key 'type*)
- (and (eq key 'timestamp) timestamp ebib-use-timestamp))
- (insert (format "\t%s = %s,\n" key value))))
- entry)
- (if (and timestamp ebib-use-timestamp)
- (insert (format "\ttimestamp = {%s}" (format-time-string ebib-timestamp-format)))
- (delete-char -2)) ; the final ",\n" must be deleted
- (insert "\n}\n\n"))))
-
-(defun ebib-format-strings (db)
- "Format the @STRING commands in database DB."
- (maphash '(lambda (key value)
- (insert (format "@STRING{%s = %s}\n" key value)))
- (edb-strings db))
- (insert "\n"))
-
-(defun ebib-compare-xrefs (x y)
- (gethash 'crossref (ebib-retrieve-entry x ebib-cur-db)))
-
-(defun ebib-format-database (db)
- "Writes database DB into the current buffer in BibTeX format."
- (when (edb-preamble db)
- (insert (format "@PREAMBLE{%s}\n\n" (edb-preamble db))))
- (ebib-format-strings db)
- (let ((sorted-list (copy-list (edb-keys-list db))))
- (cond
- (ebib-save-xrefs-first
- (setq sorted-list (sort sorted-list 'ebib-compare-xrefs)))
- (ebib-sort-order
- (setq sorted-list (sort sorted-list 'ebib-entry<))))
- (mapc '(lambda (key) (ebib-format-entry key db nil)) sorted-list)))
-
-(defun ebib-save-database (db)
- "Saves the database DB."
- (ebib-execute-when
- ((real-db)
- (when (and (edb-make-backup db)
- (file-exists-p (edb-filename db)))
- (rename-file (edb-filename db) (concat (edb-filename db) "~") t)
- (setf (edb-make-backup db) nil))
- (with-temp-buffer
- (ebib-format-database db)
- (write-region (point-min) (point-max) (edb-filename db)))
- (ebib-set-modified nil db))))
-
-(defun ebib-write-database ()
- "Writes the current database to a different file.
-
-Can also be used to change a virtual database into a real one."
- (interactive)
- (ebib-execute-when
- ((database)
- (if-str (new-filename (read-file-name "Save to file: " "~/"))
- (progn
- (with-temp-buffer
- (ebib-format-database ebib-cur-db)
- (safe-write-region (point-min) (point-max) new-filename nil nil nil t))
- ;; if SAFE-WRITE-REGION was cancelled by the user because he
- ;; didn't want to overwrite an already existing file with his
- ;; new database, it throws an error, so the next lines will not
- ;; be executed. hence we can safely set (EDB-FILENAME DB) and
- ;; (EDB-NAME DB).
- (setf (edb-filename ebib-cur-db) new-filename)
- (setf (edb-name ebib-cur-db) (file-name-nondirectory new-filename))
- (rename-buffer (concat (format " %d:" (1+ (- (length ebib-databases)
- (length (member ebib-cur-db ebib-databases)))))
- (edb-name ebib-cur-db)))
- (ebib-execute-when
- ((virtual-db)
- (setf (edb-virtual ebib-cur-db) nil)
- (let ((source-db (edb-database ebib-cur-db)))
- (setf (edb-database ebib-cur-db) (make-hash-table :test 'equal))
- (mapc '(lambda (key)
- (let ((entry (gethash key source-db)))
- (when entry
- (puthash key (copy-hash-table entry) (edb-database ebib-cur-db)))))
- (edb-keys-list ebib-cur-db)))))
- (ebib-set-modified nil))))
- ((default)
- (beep))))
-
-(defun ebib-save-current-database ()
- "Saves the current database."
- (interactive)
- (ebib-execute-when
- ((real-db)
- (if (not (edb-modified ebib-cur-db))
- (message "No changes need to be saved.")
- (ebib-save-database ebib-cur-db)))
- ((virtual-db)
- (error "Cannot save a virtual database. Use `w' to write to a file."))))
-
-(defun ebib-save-all-databases ()
- "Saves all currently open databases if they were modified."
- (interactive)
- (ebib-execute-when
- ((database)
- (mapc #'(lambda (db)
- (when (edb-modified db)
- (ebib-save-database db)))
- ebib-databases)
- (message "All databases saved."))))
-
-(defun ebib-print-filename ()
- "Displays the filename of the current database in the minibuffer."
- (interactive)
- (message (edb-filename ebib-cur-db)))
-
-(defun ebib-follow-crossref ()
- "Goes to the entry mentioned in the crossref field of the current entry."
- (interactive)
- (let ((new-cur-entry (to-raw (gethash 'crossref
- (ebib-retrieve-entry (ebib-cur-entry-key) ebib-cur-db)))))
- (setf (edb-cur-entry ebib-cur-db)
- (or (member new-cur-entry (edb-keys-list ebib-cur-db))
- (edb-cur-entry ebib-cur-db))))
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer))
-
-(defun ebib-toggle-hidden ()
- (interactive)
- (setq ebib-hide-hidden-fields (not ebib-hide-hidden-fields))
- (ebib-fill-entry-buffer))
-
-(defun ebib-delete-entry ()
- "Deletes the current entry from the database."
- (interactive)
- (ebib-execute-when
- ((real-db entries)
- (let ((cur-entry (ebib-cur-entry-key)))
- (when (y-or-n-p (format "Delete %s? " cur-entry))
- (ebib-remove-entry-from-db cur-entry ebib-cur-db)
- (ebib-remove-key-from-buffer cur-entry)
- (ebib-fill-entry-buffer)
- (ebib-set-modified t)
- (message (format "Entry `%s' deleted." cur-entry)))))
- ((default)
- (beep))))
-
-(defun ebib-remove-entry-from-db (entry-key db &optional new-cur-entry)
- "Removes ENTRY-KEY from DB.
-
-Optional argument NEW-CUR-ENTRY is the key of the entry that is to become
-the new current entry. It it is NIL, the entry after the deleted one
-becomes the new current entry. If it is T, the current entry is not
-changed."
- (remhash entry-key (edb-database db))
- (setf (edb-n-entries db) (1- (edb-n-entries db)))
- (cond
- ((null new-cur-entry) (setq new-cur-entry (cadr (edb-cur-entry db))))
- ((stringp new-cur-entry) t)
- (t (setq new-cur-entry (ebib-cur-entry-key))))
- (setf (edb-keys-list db) (delete (ebib-cur-entry-key) (edb-keys-list db)))
- (setf (edb-cur-entry db) (member new-cur-entry (edb-keys-list db)))
- (unless (edb-cur-entry db) ; if (edb-cur-entry db) is nil, we deleted the last entry.
- (setf (edb-cur-entry db) (last (edb-keys-list db)))))
-
-(defun ebib-remove-key-from-buffer (entry-key)
- "Removes ENTRY-KEY from the index buffer and highlights the current entry."
- (with-buffer-writable
- (let ((beg (ebib-search-key-in-buffer entry-key)))
- (forward-line 1)
- (delete-region beg (point))))
- (ebib-execute-when
- ((entries)
- (ebib-search-key-in-buffer (ebib-cur-entry-key))
- (ebib-set-index-highlight))))
-
-(defun ebib-select-entry ()
- "Makes the entry at (point) the current entry."
- (interactive)
- (ebib-execute-when
- ((entries)
- (beginning-of-line)
- (let ((beg (point)))
- (let* ((key (save-excursion
- (end-of-line)
- (buffer-substring-no-properties beg (point))))
- (new-cur-entry (member key (edb-keys-list ebib-cur-db))))
- (when new-cur-entry
- (setf (edb-cur-entry ebib-cur-db) new-cur-entry)
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer)))))
- ((default)
- (beep))))
-
-(defun ebib-export-entry (prefix)
- "Copies the current entry to another database.
-
-The prefix argument indicates which database to copy the entry to. If no
-prefix argument is present, a filename is asked to which the entry is
-appended."
- (interactive "P")
- (ebib-execute-when
- ((real-db entries)
- (let ((num (ebib-prefix prefix)))
- (if num
- (let ((goal-db (nth (1- num) ebib-databases))
- (entry-key (ebib-cur-entry-key)))
- (cond
- ((not goal-db)
- (error "Database %d does not exist" num))
- ((edb-virtual goal-db)
- (error "Database %d is virtual" num))
- (t
- (if (member entry-key (edb-keys-list goal-db))
- (error "Entry key `%s' already exists in database %d" entry-key num)
- (ebib-insert-entry entry-key
- (copy-hash-table (ebib-retrieve-entry entry-key ebib-cur-db))
- goal-db t t)
- (ebib-set-modified t goal-db)
- ;; if this is the first entry in GOAL-DB, its CUR-ENTRY must be set!
- (when (null (edb-cur-entry goal-db))
- (setf (edb-cur-entry goal-db) (edb-keys-list goal-db)))
- (message "Entry `%s' copied to database `%d'" entry-key num)))))
- ;; if no prefix arg was given, we export to a file
- (let ((insert-default-directory (not ebib-export-filename)))
- (if-str (filename (read-file-name
- (format "Export %s to file: " (ebib-cur-entry-key))
- "~/" nil nil ebib-export-filename))
- (with-temp-buffer
- (insert (format "\n")) ; to keep things tidy.
- (ebib-format-entry (ebib-cur-entry-key) ebib-cur-db t)
- (append-to-file (point-min) (point-max) filename)
- (setq ebib-export-filename filename)))))))
- ((default)
- (beep))))
-
-(defun ebib-search ()
- "Search the current Ebib database.
-
-The search is conducted with STRING-MATCH and can therefore be a regexp.
-Searching starts with the current entry."
- (interactive)
- (ebib-execute-when
- ((entries)
- (if-str (search-str (read-string "Search database for: "))
- (progn
- (setq ebib-search-string search-str)
- ;; first we search the current entry
- (if (ebib-search-in-entry ebib-search-string
- (ebib-retrieve-entry (ebib-cur-entry-key) ebib-cur-db))
- (ebib-fill-entry-buffer ebib-search-string)
- ;; if the search string wasn't found in the current entry, we continue searching.
- (ebib-search-next)))))
- ((default)
- (beep))))
-
-(defun ebib-search-next ()
- "Search the next occurrence of EBIB-SEARCH-STRING.
-
-Searching starts at the entry following the current entry. If a match is
-found, the matching entry is shown and becomes the new current entry."
- (interactive)
- (ebib-execute-when
- ((entries)
- (if (null ebib-search-string)
- (message "No search string")
- (let ((cur-search-entry (cdr (edb-cur-entry ebib-cur-db))))
- (while (and cur-search-entry
- (null (ebib-search-in-entry ebib-search-string
- (gethash (car cur-search-entry)
- (edb-database ebib-cur-db)))))
- (setq cur-search-entry (cdr cur-search-entry)))
- (if (null cur-search-entry)
- (message (format "`%s' not found" ebib-search-string))
- (setf (edb-cur-entry ebib-cur-db) cur-search-entry)
- (set-buffer ebib-index-buffer)
- (goto-char (point-min))
- (re-search-forward (format "^%s$" (ebib-cur-entry-key)))
- (beginning-of-line)
- (ebib-set-index-highlight)
- (ebib-fill-entry-buffer ebib-search-string)))))
- ((default)
- (beep))))
-
-(defun ebib-search-in-entry (search-str entry &optional field)
- "Searches one entry of the ebib database.
-
-Returns a list of fields in ENTRY that match the regexp SEARCH-STR,
-or NIL if no matches were found. If FIELD is given, only that
-field is searched."
- (let ((case-fold-search t) ; we want to ensure a case-insensitive search
- (result nil))
- (if field
- (let ((value (gethash field entry)))
- (when (and (stringp value) ; the type* field has a symbol as value
- (string-match search-str value))
- (setq result (list field))))
- (maphash '(lambda (field value)
- (when (and (stringp value) ; the type* field has a symbol as value
- (string-match search-str value))
- (setq result (cons field result))))
- entry))
- result))
-
-(defun ebib-edit-strings ()
- "Edits the @STRING definitions in the database."
- (interactive)
- (ebib-execute-when
- ((real-db)
- (ebib-fill-strings-buffer)
- (other-window 1)
- (switch-to-buffer ebib-strings-buffer)
- (goto-char (point-min)))
- ((default)
- (beep))))
-
-(defun ebib-edit-preamble ()
- "Edits the @PREAMBLE definition in the database."
- (interactive)
- (ebib-execute-when
- ((real-db)
- (other-window 1) ; we want the multiline edit buffer to appear in the lower window
- (ebib-multiline-edit 'preamble (edb-preamble ebib-cur-db)))
- ((default)
- (beep))))
-
-(defun ebib-export-preamble (prefix)
- "Export the @PREAMBLE definition.
-
-If a prefix argument was given, it is taken as the database to export the
-preamble to. If the goal database already has a preamble, the new preamble
-will be appended to it. If no prefix argument is given, the user is asked
-to enter a filename to which the preamble is appended."
- (interactive "P")
- (ebib-execute-when
- ((real-db)
- (if (null (edb-preamble ebib-cur-db))
- (error "No @PREAMBLE defined")
- (let ((text (edb-preamble ebib-cur-db))
- (num (ebib-prefix prefix)))
- (if num
- ;; we have a prefix argument
- (let ((goal-db (nth (1- num) ebib-databases)))
- (cond
- ((not goal-db)
- (error "Database %d does not exist" num))
- ((edb-virtual goal-db)
- (error "Database %d is virtual" num))
- (t
- (if (edb-preamble goal-db)
- (setf (edb-preamble goal-db) (concat (edb-preamble goal-db) "\n# " text))
- (setf (edb-preamble goal-db) text))
- (message (format "@PREAMBLE copied to database %d" num))
- (ebib-set-modified t goal-db))))
- ;; if no prefix argument was given, we export to a file
- (let ((insert-default-directory (not ebib-export-filename)))
- (if-str (filename (read-file-name
- "Export @PREAMBLE to file: "
- "~/" nil nil ebib-export-filename))
- (with-temp-buffer
- (insert (format "\n@PREAMBLE{%s}\n\n" (edb-preamble ebib-cur-db)))
- (append-to-file (point-min) (point-max) filename)
- (message (format "@PREAMBLE exported to file %s"
- (file-name-nondirectory filename)))
- (setq ebib-export-filename filename))))))))
- ((default)
- (beep))))
-
-(defun ebib-print-database ()
- "Creates a LaTeX file from the contents of the database."
- (interactive)
- (ebib-execute-when
- ((entries)
- (if-str (tempfile (if (not (string= "" ebib-print-tempfile))
- ebib-print-tempfile
- (read-file-name "Use temp file: " "~/" nil nil)))
- (with-temp-buffer
- (insert "\\documentclass{article}\n\n")
- (when ebib-print-preamble
- (mapc '(lambda (string)
- (insert (format "%s\n" string)))
- ebib-print-preamble))
- (insert "\n\\begin{document}\n\n")
- (mapc '(lambda (entry-key)
- (insert "\\begin{tabular}{p{0.2\\textwidth}p{0.8\\textwidth}}\n")
- (let ((entry (ebib-retrieve-entry entry-key ebib-cur-db)))
- (insert (format "\\multicolumn{2}{l}{\\texttt{%s (%s)}}\\\\\n"
- entry-key (symbol-name (gethash 'type* entry))))
- (insert "\\hline\n")
- (mapc '(lambda (field)
- (if-str (value (gethash field entry))
- (when (or (not (multiline-p value))
- ebib-print-multiline)
- (insert (format "%s: & %s\\\\\n"
- field (to-raw value))))))
- (cdr (ebib-get-all-fields (gethash 'type* entry)))))
- (insert "\\end{tabular}\n\n")
- (insert "\\bigskip\n\n"))
- (edb-keys-list ebib-cur-db))
- (insert "\\end{document}\n")
- (write-region (point-min) (point-max) tempfile)
- (ebib-lower)
- (find-file tempfile))))))
-
-(defun ebib-latex-database ()
- "Creates a LaTeX file that \nocite's all entries in the database."
- (interactive)
- (ebib-execute-when
- ((real-db entries)
- (if-str (tempfile (if (not (string= "" ebib-print-tempfile))
- ebib-print-tempfile
- (read-file-name "Use temp file: " "~/" nil nil)))
- (with-temp-buffer
- (insert "\\documentclass{article}\n\n")
- (when ebib-print-preamble
- (mapc '(lambda (string)
- (insert (format "%s\n" string)))
- ebib-latex-preamble))
- (insert "\n\\begin{document}\n\n")
- (insert "\\nocite{*}\n\n")
- (insert (format "\\bibliography{%s}\n\n" (expand-file-name (edb-filename ebib-cur-db))))
- (insert "\\end{document}\n")
- (write-region (point-min) (point-max) tempfile)
- (ebib-lower)
- (find-file tempfile))))))
-
-(defun ebib-switch-to-database (num)
- (interactive "NSwitch to database number: ")
- (let ((new-db (nth (1- num) ebib-databases)))
- (if new-db
- (progn
- (setq ebib-cur-db new-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer))
- (error "Database %d does not exist" num))))
-
-(defun ebib-next-database ()
- (interactive)
- (ebib-execute-when
- ((database)
- (let ((new-db (next-elem ebib-cur-db ebib-databases)))
- (unless new-db
- (setq new-db (car ebib-databases)))
- (setq ebib-cur-db new-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer)))))
-
-(defun ebib-prev-database ()
- (interactive)
- (ebib-execute-when
- ((database)
- (let ((new-db (prev-elem ebib-cur-db ebib-databases)))
- (unless new-db
- (setq new-db (last1 ebib-databases)))
- (setq ebib-cur-db new-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer)))))
-
-(defun ebib-virtual-db-and (not)
- "Filter entries into a virtual database.
-
-If the current database is a virtual database already, perform a
-logical AND on the entries."
- (interactive "p")
- (ebib-execute-when
- ((entries)
- (ebib-filter-to-virtual-db 'and not))
- ((default)
- (beep))))
-
-(defun ebib-virtual-db-or (not)
- "Filter entries into a virtual database.
-
-If the current database is a virtual database already, perform a
-logical OR with the entries in the original database."
- (interactive "p")
- (ebib-execute-when
- ((entries)
- (ebib-filter-to-virtual-db 'or not))
- ((default)
- (beep))))
-
-(defun ebib-virtual-db-not ()
- "Negates the current virtual database."
- (interactive)
- (ebib-execute-when
- ((virtual-db)
- (setf (edb-virtual ebib-cur-db)
- (if (eq (car (edb-virtual ebib-cur-db)) 'not)
- (cadr (edb-virtual ebib-cur-db))
- `(not ,(edb-virtual ebib-cur-db))))
- (ebib-run-filter (edb-virtual ebib-cur-db) ebib-cur-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer))
- ((default)
- (beep))))
-
-(defun ebib-filter-to-virtual-db (bool not)
- "Filters the current database to a virtual database.
-
-BOOL is the operator to be used, either `and' or `or'. If NOT<0,
-a logical `not' is applied to the selection."
- (let ((field (completing-read "Field to filter on: "
- (cons '("any" 0)
- (mapcar '(lambda (x)
- (cons (symbol-name x) 0))
- (append ebib-unique-field-list ebib-additional-fields)))
- nil t)))
- (if (string= field "type")
- (message "Cannot filter on `type' field ")
- (setq field (intern-soft field))
- (let ((regexp (read-string "Regexp to filter with: ")))
- (ebib-execute-when
- ((virtual-db)
- (setf (edb-virtual ebib-cur-db) `(,bool ,(edb-virtual ebib-cur-db)
- ,(if (>= not 0)
- `(contains ,field ,regexp)
- `(not (contains ,field ,regexp))))))
- ((real-db)
- (setq ebib-cur-db (ebib-create-virtual-db field regexp not))))
- (ebib-run-filter (edb-virtual ebib-cur-db) ebib-cur-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer)))))
-
-(defun ebib-create-virtual-db (field regexp not)
- "Creates a virtual database based on EBIB-CUR-DB."
- ;; a virtual database is a database whose edb-virtual field contains an
- ;; expression that selects entries. this function only sets that
- ;; expression, it does not actually filter the entries.
- (let ((new-db (ebib-create-new-database ebib-cur-db)))
- (setf (edb-virtual new-db) (if (>= not 0)
- `(contains ,field ,regexp)
- `(not (contains ,field ,regexp))))
- (setf (edb-filename new-db) nil)
- (setf (edb-name new-db) (concat "V:" (edb-name new-db)))
- (setf (edb-modified new-db) nil)
- (setf (edb-make-backup new-db) nil)
- new-db))
-
-(defmacro contains (field regexp)
- ;; This is a hack: CONTAINS depends on the variable ENTRY being set to an
- ;; actual Ebib entry for its operation. The point of this macro is to
- ;; facilitate defining filters for virtual databases. It enables us to
- ;; define filters of the form:
-
- ;; (and (not (contains author "Chomsky")) (contains year "1995"))
-
- `(ebib-search-in-entry ,regexp entry ,(unless (eq field 'any) `(quote ,field))))
-
-(defun ebib-run-filter (filter db)
- "Run FILTER on DB"
- (setf (edb-keys-list db)
- (sort (let ((result nil))
- (maphash '(lambda (key value)
- (let ((entry value)) ; this is necessary for actually running the filter
- (when (eval filter)
- (setq result (cons key result)))))
- (edb-database db))
- result)
- 'string<))
- (setf (edb-n-entries db) (length (edb-keys-list db)))
- (setf (edb-cur-entry db) (edb-keys-list db)))
-
-(defun ebib-print-filter (num)
- "Display the filter of the current virtual database.
-
-With any prefix argument, reapplies the filter to the
-database. This can be useful when the source database was
-modified."
- (interactive "P")
- (ebib-execute-when
- ((virtual-db)
- (when num
- (ebib-run-filter (edb-virtual ebib-cur-db) ebib-cur-db)
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer))
- (message "%S" (edb-virtual ebib-cur-db)))
- ((default)
- (beep))))
-
-(defun ebib-index-help ()
- "Displays the help message for the index buffer."
- (interactive)
- (other-window 1)
- (ebib-display-help ebib-index-buffer))
-
-;;;;;;;;;;;;;;;;
-;; entry-mode ;;
-;;;;;;;;;;;;;;;;
-
-(defvar ebib-entry-mode-map
- (let ((map (make-keymap 'ebib-entry-mode-map)))
- (suppress-keymap map)
- (define-key map [up] 'ebib-prev-field)
- (define-key map [down] 'ebib-next-field)
- (define-key map "k" 'ebib-prev-field)
- (define-key map "j" 'ebib-next-field)
- (define-key map [(control p)] 'ebib-prev-field)
- (define-key map [(control n)] 'ebib-next-field)
- (define-key map [prior] 'ebib-goto-prev-set)
- (define-key map [next] 'ebib-goto-next-set)
- (define-key map [(meta p)] 'ebib-goto-next-set)
- (define-key map [(meta n)] 'ebib-goto-prev-set)
- (define-key map " " 'ebib-goto-next-set)
- (define-key map "b" 'ebib-goto-prev-set)
- (define-key map [home] 'ebib-goto-first-field)
- (define-key map [end] 'ebib-goto-last-field)
- (define-key map "g" 'ebib-goto-first-field)
- (define-key map "G" 'ebib-goto-last-field)
- (define-key map "e" 'ebib-edit-field)
- (define-key map "q" 'ebib-quit-entry-buffer)
- (define-key map "c" 'ebib-copy-field-contents)
- (define-key map "x" 'ebib-cut-field-contents)
- (define-key map "y" 'ebib-yank-field-contents)
- (define-key map "d" 'ebib-delete-field-contents)
- (define-key map "r" 'ebib-toggle-raw)
- (define-key map "l" 'ebib-edit-multiline-field)
- (define-key map "s" 'ebib-insert-abbreviation)
- (define-key map "h" 'ebib-entry-help)
- (define-key map "\C-xb" 'disabled)
- (define-key map "\C-xk" 'disabled)
- map)
- "Keymap for the Ebib entry buffer.")
-
-(define-derived-mode ebib-entry-mode
- fundamental-mode "Ebib-entry"
- "Major mode for the Ebib entry buffer."
- (setq buffer-read-only t)
- (setq truncate-lines t))
-
-(defun ebib-quit-entry-buffer ()
- "Quit editing the entry."
- (interactive)
- (other-window 1))
-
-(defun ebib-find-visible-field (field direction)
- "Finds the first visible field before or after FIELD.
-
-If DIRECTION is negative, search the preceding fields, otherwise
-search the succeeding fields. If FIELD is visible itself, return
-that. If there is no preceding/following visible field, return
-NIL. If EBIB-HIDE-HIDDEN-FIELDS is NIL, return FIELD."
- (when ebib-hide-hidden-fields
- (let ((fn (if (>= direction 0)
- 'next-elem
- 'prev-elem)))
- (while (and field
- (get field 'ebib-hidden))
- (setq field (funcall fn field ebib-cur-entry-fields)))))
- field)
-
-(defun ebib-prev-field ()
- "Move to the previous field."
- (interactive)
- (let ((new-field (ebib-find-visible-field (prev-elem ebib-current-field ebib-cur-entry-fields) -1)))
- (if (null new-field)
- (beep)
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field -1))))
-
-(defun ebib-next-field ()
- "Move to the next field."
- (interactive)
- (let ((new-field (ebib-find-visible-field (next-elem ebib-current-field ebib-cur-entry-fields) 1)))
- (if (null new-field)
- (when (interactive-p) ; i call this function after editing a field,
- ; and we don't want a beep then
- (beep))
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field 1))))
-
-(defun ebib-goto-first-field ()
- "Move to the first field."
- (interactive)
- (let ((new-field (ebib-find-visible-field (car ebib-cur-entry-fields) 1)))
- (if (null new-field)
- (beep)
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field -1))))
-
-(defun ebib-goto-last-field ()
- "Move to the last field."
- (interactive)
- (let ((new-field (ebib-find-visible-field (last1 ebib-cur-entry-fields) -1)))
- (if (null new-field)
- (beep)
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field 1))))
-
-(defun ebib-goto-next-set ()
- "Move to the next set of fields."
- (interactive)
- (cond
- ((eq ebib-current-field 'type*) (ebib-next-field))
- ((member ebib-current-field ebib-additional-fields) (ebib-goto-last-field))
- (t (let* ((entry-type (gethash 'type* ebib-cur-entry-hash))
- (obl-fields (ebib-get-obl-fields entry-type))
- (opt-fields (ebib-get-opt-fields entry-type))
- (new-field nil))
- (when (member ebib-current-field obl-fields)
- (setq new-field (ebib-find-visible-field (car opt-fields) 1)))
- ;; new-field is nil if there are no opt-fields
- (when (or (member ebib-current-field opt-fields)
- (null new-field))
- (setq new-field (ebib-find-visible-field (car ebib-additional-fields) 1)))
- (if (null new-field)
- (ebib-goto-last-field) ; if there was no further set to go to,
- ; go to the last field of the current set
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field 1))))))
-
-(defun ebib-goto-prev-set ()
- "Move to the previous set of fields."
- (interactive)
- (unless (eq ebib-current-field 'type*)
- (let* ((entry-type (gethash 'type* ebib-cur-entry-hash))
- (obl-fields (ebib-get-obl-fields entry-type))
- (opt-fields (ebib-get-opt-fields entry-type))
- (new-field nil))
- (if (member ebib-current-field obl-fields)
- (ebib-goto-first-field)
- (when (member ebib-current-field ebib-additional-fields)
- (setq new-field (ebib-find-visible-field (last1 opt-fields) -1)))
- (when (or (member ebib-current-field opt-fields)
- (null new-field))
- (setq new-field (ebib-find-visible-field (last1 obl-fields) -1)))
- (if (null new-field)
- (ebib-goto-first-field)
- (setq ebib-current-field new-field)
- (ebib-move-to-field ebib-current-field -1))))))
-
-(defun ebib-edit-entry-type ()
- "Edits the type of an entry."
- ;; we want to put the completion buffer in the lower window. for this
- ;; reason, we need to switch to the other window before calling
- ;; completing-read. but in order to make sure that we return to the
- ;; entry buffer and not the index buffer when the user presses C-g, we
- ;; need to do this in an unwind-protect.
- (unwind-protect
- (progn
- (other-window 1)
- (let ((collection (ebib-create-collection ebib-entry-types-hash)))
- (if-str (new-type (completing-read "type: " collection nil t))
- (progn
- (puthash 'type* (intern-soft new-type) ebib-cur-entry-hash)
- (ebib-fill-entry-buffer)
- (setq ebib-cur-entry-fields (ebib-get-all-fields (gethash 'type* ebib-cur-entry-hash)))
- (ebib-set-modified t)))))
- (other-window 1)))
-
-(defun ebib-edit-crossref ()
- "Edits the crossref field."
- (unwind-protect
- (progn
- (other-window 1)
- (let ((collection (ebib-create-collection (edb-database ebib-cur-db))))
- (if-str (key (completing-read "Key to insert in `crossref': " collection nil t))
- (progn
- (puthash 'crossref (from-raw key) ebib-cur-entry-hash)
- (ebib-set-modified t)))))
- (other-window 1)
- (ebib-redisplay-current-field)))
-
-;; we should modify ebib-edit-field, so that it calls the appropriate
-;; helper function, which asks the user for the new value and just returns
-;; that. storing it should then be done by ebib-edit-field, no matter what
-;; sort of field the user edits.
-
-(defun ebib-edit-field ()
- "Edits a field of a BibTeX entry."
- (interactive)
- (cond
- ((eq ebib-current-field 'type*) (ebib-edit-entry-type))
- ((eq ebib-current-field 'crossref) (ebib-edit-crossref))
- ((eq ebib-current-field 'annote) (ebib-edit-multiline-field))
- (t
- (let ((init-contents (gethash ebib-current-field ebib-cur-entry-hash))
- (raw nil))
- (if (multiline-p init-contents)
- (ebib-edit-multiline-field)
- (when init-contents
- (if (raw-p init-contents)
- (setq raw t)
- (setq init-contents (to-raw init-contents))))
- (if-str (new-contents (read-string (format "%s: " (symbol-name ebib-current-field))
- (if init-contents
- (cons init-contents 0)
- nil)
- ebib-minibuf-hist))
- (puthash ebib-current-field (if raw
- new-contents
- (from-raw new-contents))
- ebib-cur-entry-hash)
- (remhash ebib-current-field ebib-cur-entry-hash))
- (ebib-redisplay-current-field)
- ;; we move to the next field, but only if ebib-edit-field was
- ;; called interactively, otherwise we get a strange bug in
- ;; ebib-toggle-raw...
- (if (interactive-p) (ebib-next-field))
- (ebib-set-modified t))))))
-
-(defun ebib-copy-field-contents ()
- "Copies the contents of the current field to the kill ring."
- (interactive)
- (unless (eq ebib-current-field 'type*)
- (let ((contents (gethash ebib-current-field ebib-cur-entry-hash)))
- (when (stringp contents)
- (kill-new contents)
- (message "Field contents copied.")))))
-
-(defun ebib-cut-field-contents ()
- "Kills the contents of the current field. The killed text is put in the kill ring."
- (interactive)
- (unless (eq ebib-current-field 'type*)
- (let ((contents (gethash ebib-current-field ebib-cur-entry-hash)))
- (when (stringp contents)
- (remhash ebib-current-field ebib-cur-entry-hash)
- (kill-new contents)
- (ebib-redisplay-current-field)
- (ebib-set-modified t)
- (message "Field contents killed.")))))
-
-(defun ebib-yank-field-contents (arg)
- "Inserts the last killed text into the current field.
-
-If the current field already has a contents, nothing is inserted,
-unless the previous command was also ebib-yank-field-contents,
-then the field contents is replaced with the previous yank. That
-is, multiple use of this command functions like the combination
-of C-y/M-y. Prefix arguments also work the same as with C-y/M-y."
- (interactive "P")
- (if (or (eq ebib-current-field 'type*) ; we cannot yank into the type* or crossref fields
- (eq ebib-current-field 'crossref)
- (unless (eq last-command 'ebib-yank-field-contents)
- (gethash ebib-current-field ebib-cur-entry-hash))) ; nor into a field already filled
- (progn
- (setq this-command t)
- (beep))
- (let ((new-contents (current-kill (cond
- ((listp arg) (if (eq last-command 'ebib-yank-field-contents)
- 1
- 0))
- ((eq arg '-) -2)
- (t (1- arg))))))
- (when new-contents
- (puthash ebib-current-field new-contents ebib-cur-entry-hash)
- (ebib-redisplay-current-field)
- (ebib-set-modified t)))))
-
-(defun ebib-delete-field-contents ()
- "Deletes the contents of the current field. The deleted text is not put
-in the kill ring."
- (interactive)
- (if (eq ebib-current-field 'type*)
- (beep)
- (remhash ebib-current-field ebib-cur-entry-hash)
- (ebib-redisplay-current-field)
- (ebib-set-modified t)
- (message "Field contents deleted.")))
-
-(defun ebib-toggle-raw ()
- "Toggles the raw status of the current field contents."
- (interactive)
- (unless (or (eq ebib-current-field 'type*)
- (eq ebib-current-field 'crossref))
- (let ((contents (gethash ebib-current-field ebib-cur-entry-hash)))
- (if (not contents) ; if there is no value,
- (progn
- (ebib-edit-field) ; the user can enter one, which we must then make raw
- (let ((new-contents (gethash ebib-current-field ebib-cur-entry-hash)))
- (when new-contents
- ;; note: we don't have to check for empty string, since that is
- ;; already done in ebib-edit-field
- (puthash ebib-current-field (to-raw new-contents) ebib-cur-entry-hash))))
- (if (raw-p contents)
- (puthash ebib-current-field (from-raw contents) ebib-cur-entry-hash)
- (puthash ebib-current-field (to-raw contents) ebib-cur-entry-hash)))
- (ebib-redisplay-current-field)
- (ebib-set-modified t))))
-
-(defun ebib-edit-multiline-field ()
- "Edits the current field in multiline-mode."
- (interactive)
- (unless (or (eq ebib-current-field 'type*)
- (eq ebib-current-field 'crossref))
- (let ((text (gethash ebib-current-field ebib-cur-entry-hash)))
- (if (raw-p text)
- (setq ebib-multiline-raw t)
- (setq text (to-raw text))
- (setq ebib-multiline-raw nil))
- (ebib-multiline-edit 'fields text))))
-
-(defun ebib-insert-abbreviation ()
- "Insert an abbreviation from the ones defined in the database."
- (interactive)
- (if (gethash ebib-current-field ebib-cur-entry-hash)
- (beep)
- (when (edb-strings-list ebib-cur-db)
- (unwind-protect
- (progn
- (other-window 1)
- (let* ((collection (ebib-create-collection (edb-strings ebib-cur-db)))
- (string (completing-read "Abbreviation to insert: " collection nil t)))
- (when string
- (puthash ebib-current-field string ebib-cur-entry-hash)
- (ebib-set-modified t))))
- (other-window 1)
- ;; we can't do this earlier, because we would be writing to the index buffer...
- (ebib-redisplay-current-field)
- (ebib-next-field)))))
-
-(defun ebib-entry-help ()
- "Displays the help message for the entry buffer."
- (interactive)
- (ebib-display-help ebib-entry-buffer))
-
-;;;;;;;;;;;;;;;;;;
-;; strings-mode ;;
-;;;;;;;;;;;;;;;;;;
-
-(defvar ebib-strings-mode-map
- (let ((map (make-keymap 'ebib-strings-mode-map)))
- (suppress-keymap map)
- (define-key map [up] 'ebib-prev-string)
- (define-key map [down] 'ebib-next-string)
- (define-key map "k" 'ebib-prev-string)
- (define-key map "j" 'ebib-next-string)
- (define-key map [(control p)] 'ebib-prev-string)
- (define-key map [(control n)] 'ebib-next-string)
- (define-key map "e" 'ebib-edit-string)
- (define-key map "g" 'ebib-goto-first-string)
- (define-key map "G" 'ebib-goto-last-string)
- (define-key map [prior] 'ebib-strings-page-up)
- (define-key map [next] 'ebib-strings-page-down)
- (define-key map "b" 'ebib-strings-page-up)
- (define-key map " " 'ebib-strings-page-down)
- (define-key map [(meta p)] 'ebib-strings-page-up)
- (define-key map [(meta n)] 'ebib-strings-page-down)
- (define-key map [home] 'ebib-goto-first-string)
- (define-key map [end] 'ebib-goto-last-string)
- (define-key map "q" 'ebib-quit-strings-buffer)
- (define-key map "c" 'ebib-copy-string-contents)
- (define-key map "d" 'ebib-delete-string)
- (define-key map "a" 'ebib-add-string)
- (define-key map "l" 'ebib-edit-multiline-string)
- (define-key map "x" 'ebib-export-string)
- (define-key map "X" 'ebib-export-all-strings)
- (define-key map "h" 'ebib-strings-help)
- (define-key map "\C-xb" 'disabled)
- (define-key map "\C-xk" 'disabled)
- map)
- "Keymap for the ebib strings buffer.")
-
-(define-derived-mode ebib-strings-mode
- fundamental-mode "Ebib-strings"
- "Major mode for the Ebib strings buffer."
- (setq buffer-read-only t)
- (setq truncate-lines t))
-
-(defun ebib-quit-strings-buffer ()
- "Quit editing the @STRING definitions."
- (interactive)
- (switch-to-buffer ebib-entry-buffer)
- (other-window 1))
-
-(defun ebib-prev-string ()
- "Move to the previous string."
- (interactive)
- (if (equal ebib-current-string (car (edb-strings-list ebib-cur-db))) ; if we're on the first string
- (beep)
- ;; go to the beginnig of the highlight and move upward one line.
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (forward-line -1)
- (setq ebib-current-string (prev-elem ebib-current-string (edb-strings-list ebib-cur-db)))
- (ebib-set-strings-highlight)))
-
-(defun ebib-next-string ()
- "Move to the next string."
- (interactive)
- (if (equal ebib-current-string (last1 (edb-strings-list ebib-cur-db)))
- (when (interactive-p) (beep))
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (forward-line 1)
- (setq ebib-current-string (next-elem ebib-current-string (edb-strings-list ebib-cur-db)))
- (ebib-set-strings-highlight)))
-
-(defun ebib-goto-first-string ()
- "Move to the first string."
- (interactive)
- (setq ebib-current-string (car (edb-strings-list ebib-cur-db)))
- (goto-char (point-min))
- (ebib-set-strings-highlight))
-
-(defun ebib-goto-last-string ()
- "Move to the last string."
- (interactive)
- (setq ebib-current-string (last1 (edb-strings-list ebib-cur-db)))
- (goto-char (point-max))
- (forward-line -1)
- (ebib-set-strings-highlight))
-
-(defun ebib-strings-page-up ()
- "Moves 10 entries up in the database."
- (interactive)
- (let ((number-of-strings (length (edb-strings-list ebib-cur-db)))
- (remaining-number-of-strings (length (member ebib-current-string (edb-strings-list ebib-cur-db)))))
- (if (<= (- number-of-strings remaining-number-of-strings) 10)
- (ebib-goto-first-string)
- (setq ebib-current-string (nth
- (- number-of-strings remaining-number-of-strings 10)
- (edb-strings-list ebib-cur-db)))
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (forward-line -10)
- (ebib-set-strings-highlight)))
- (message ebib-current-string))
-
-(defun ebib-strings-page-down ()
- "Moves 10 entries down in the database."
- (interactive)
- (let ((number-of-strings (length (edb-strings-list ebib-cur-db)))
- (remaining-number-of-strings (length (member ebib-current-string (edb-strings-list ebib-cur-db)))))
- (if (<= remaining-number-of-strings 10)
- (ebib-goto-last-string)
- (setq ebib-current-string (nth
- (- number-of-strings remaining-number-of-strings -10)
- (edb-strings-list ebib-cur-db)))
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (forward-line 10)
- (ebib-set-strings-highlight)))
- (message ebib-current-string))
-
-(defun ebib-fill-strings-buffer ()
- "Fills the strings buffer with the @STRING definitions."
- (set-buffer ebib-strings-buffer)
- (with-buffer-writable
- (erase-buffer)
- (dolist (elem (edb-strings-list ebib-cur-db))
- (let ((str (to-raw (gethash elem (edb-strings ebib-cur-db)))))
- (insert (format "%-18s %s\n" elem
- (if (multiline-p str)
- (concat "+" (first-line str))
- (concat " " str)))))))
- (goto-char (point-min))
- (setq ebib-current-string (car (edb-strings-list ebib-cur-db)))
- (ebib-set-strings-highlight)
- (set-buffer-modified-p nil))
-
-(defun ebib-edit-string ()
- "Edits the value of an @STRING definition
-
-When the user enters an empty string, the value is not changed."
- (interactive)
- (let ((init-contents (to-raw (gethash ebib-current-string (edb-strings ebib-cur-db)))))
- (if (multiline-p init-contents)
- (ebib-edit-multiline-string)
- (if-str (new-contents (read-string (format "%s: " ebib-current-string)
- (if init-contents
- (cons init-contents 0)
- nil)
- ebib-minibuf-hist))
- (progn
- (puthash ebib-current-string (from-raw new-contents) (edb-strings ebib-cur-db))
- (ebib-redisplay-current-string)
- (ebib-next-string)
- (ebib-set-modified t))
- (error "@STRING definition cannot be empty")))))
-
-(defun ebib-copy-string-contents ()
- "Copies the contents of the current string to the kill ring."
- (interactive)
- (let ((contents (gethash ebib-current-string (edb-strings ebib-cur-db))))
- (kill-new contents)
- (message "String value copied.")))
-
-(defun ebib-delete-string ()
- "Deletes the current @STRING definition from the database."
- (interactive)
- (when (y-or-n-p (format "Delete @STRING definition %s? " ebib-current-string))
- (remhash ebib-current-string (edb-strings ebib-cur-db))
- (with-buffer-writable
- (let ((beg (progn
- (goto-char (ebib-highlight-start ebib-strings-highlight))
- (point))))
- (forward-line 1)
- (delete-region beg (point))))
- (let ((new-cur-string (next-elem ebib-current-string (edb-strings-list ebib-cur-db))))
- (setf (edb-strings-list ebib-cur-db) (delete ebib-current-string (edb-strings-list ebib-cur-db)))
- (when (null new-cur-string) ; deleted the last string
- (setq new-cur-string (last1 (edb-strings-list ebib-cur-db)))
- (forward-line -1))
- (setq ebib-current-string new-cur-string))
- (ebib-set-strings-highlight)
- (ebib-set-modified t)
- (message "@STRING definition deleted.")))
-
-(defun ebib-add-string ()
- "Creates a new @STRING definition."
- (interactive)
- (if-str (new-abbr (read-string "New @STRING abbreviation: "))
- (progn
- (if (member new-abbr (edb-strings-list ebib-cur-db))
- (error (format "%s already exists" new-abbr)))
- (if-str (new-string (read-string (format "Value for %s: " new-abbr)))
- (progn
- (ebib-insert-string new-abbr new-string ebib-cur-db t)
- (sort-in-buffer (length (edb-strings-list ebib-cur-db)) new-abbr)
- (with-buffer-writable
- (insert (format "%-19s %s\n" new-abbr new-string)))
- (forward-line -1)
- (ebib-set-strings-highlight)
- (setq ebib-current-string new-abbr)
- (ebib-set-modified t))))))
-
-(defun ebib-export-all-strings (prefix)
- "Exports all @STRING definitions.
-
-If a prefix argument is given, it is taken as the database to copy the
-definitions to. Without prefix argument, asks for a file to append them
-to."
- (interactive "P")
- (when ebib-current-string ; there is always a current string, unless there are no strings
- (let ((num (ebib-prefix prefix)))
- (if num
- (let ((goal-db (nth (1- num) ebib-databases)))
- (cond
- ((not goal-db)
- (error "Database %d does not exist" num))
- ((edb-virtual goal-db)
- (error "Database %d is virtual" num))
- (t (mapc #'(lambda (abbr)
- (if (member abbr (edb-strings-list goal-db))
- (message "@STRING definition `%s' already exists in database %d" abbr num)
- (ebib-insert-string abbr (gethash abbr (edb-strings ebib-cur-db)) goal-db t)))
- (edb-strings-list ebib-cur-db))
- (message "All @STRING definitions copied to database %d" num))))
- ;; if there is no prefix arg, we export to a file
- (let ((insert-default-directory (not ebib-export-filename)))
- (if-str (filename (read-file-name
- "Export all @STRING definitions to file: "
- "~/" nil nil ebib-export-filename))
- (with-temp-buffer
- (insert (format "\n")) ; to keep things tidy.
- (ebib-format-strings ebib-cur-db)
- (append-to-file (point-min) (point-max) filename)
- (setq ebib-export-filename filename))))))))
-
-(defun ebib-export-string (prefix)
- "Appends the current @STRING definition to a file."
- (interactive "P")
- (when ebib-current-string
- (let ((abbr ebib-current-string)
- (string (gethash ebib-current-string (edb-strings ebib-cur-db)))
- (num (ebib-prefix prefix)))
- (if num
- (let ((goal-db (nth (1- num) ebib-databases)))
- (cond
- ((not goal-db)
- (error "Database %d does not exist" num))
- ((edb-virtual goal-db)
- (error "Database %d is virtual" num))
- ((member abbr (edb-strings-list goal-db))
- (error "@STRING definition `%s' already exists in database %d" abbr num))
- (t (ebib-insert-string abbr string goal-db t)
- (message "@STRING definition `%s' copied to database %d" abbr num))))
- (let ((insert-default-directory (not ebib-export-filename)))
- (if-str (filename (read-file-name
- (format "Export @STRING definition `%s' to file: " abbr)
- "~/" nil nil ebib-export-filename))
- (with-temp-buffer
- (insert (format "\n@STRING{%s = %s}\n"
- abbr
- string))
- (append-to-file (point-min) (point-max) filename)
- (setq ebib-export-filename filename))))))))
-
-(defun ebib-edit-multiline-string ()
- "Edits the current string in multiline-mode."
- (interactive)
- (ebib-multiline-edit 'string (to-raw (gethash ebib-current-string (edb-strings ebib-cur-db)))))
-
-(defun ebib-strings-help ()
- "Displays the help message for the strings buffer."
- (interactive)
- (ebib-display-help ebib-strings-buffer))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;
-;; multiline edit mode ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define-derived-mode ebib-multiline-edit-mode
- text-mode "Ebib-edit"
- "Major mode for editing multiline strings in Ebib."
- ;; we redefine some basic keys because we need them to leave this buffer.
- (local-set-key "\C-xb" 'ebib-leave-multiline-edit)
- (local-set-key "\C-x\C-s" 'ebib-save-from-multiline-edit)
- (local-set-key "\C-xk" 'ebib-cancel-multiline-edit))
-
-(defun ebib-multiline-edit (type &optional starttext)
- "Switches to Ebib's multiline edit buffer.
-
-STARTTEXT is a string that contains the initial text of the buffer."
- ;; note: the buffer is put in the currently active window!
- (switch-to-buffer ebib-multiline-buffer)
- (erase-buffer)
- (setq ebib-editing type)
- (when starttext
- (insert starttext)
- (goto-char (point-min))
- (set-buffer-modified-p nil)))
-
-(defun ebib-leave-multiline-edit ()
- "Quits the multiline edit buffer."
- (interactive)
- (ebib-store-multiline-text)
- (cond
- ((eq ebib-editing 'preamble)
- (switch-to-buffer ebib-entry-buffer)
- (other-window 1)) ; we have to switch back to the index buffer window
- ((eq ebib-editing 'fields)
- (switch-to-buffer ebib-entry-buffer)
- (ebib-redisplay-current-field)
- (ebib-next-field))
- ((eq ebib-editing 'strings)
- (switch-to-buffer ebib-strings-buffer)
- (ebib-redisplay-current-string)
- (ebib-next-string)))
- (message "Text stored."))
-
-(defun ebib-save-from-multiline-edit ()
- "Stores the text being edited in the multiline edit buffer and then saves the database."
- (interactive)
- (ebib-store-multiline-text)
- (ebib-save-database ebib-cur-db)
- (set-buffer-modified-p nil))
-
-(defun ebib-store-multiline-text ()
- "Stores the text being edited in the multiline edit buffer."
- (let ((text (buffer-substring-no-properties (point-min) (point-max))))
- (cond
- ((eq ebib-editing 'preamble)
- (if (equal text "")
- (setf (edb-preamble ebib-cur-db) nil)
- (setf (edb-preamble ebib-cur-db) text)))
- ((eq ebib-editing 'fields)
- (if (equal text "")
- (remhash ebib-current-field ebib-cur-entry-hash)
- (when (not ebib-multiline-raw)
- (setq text (from-raw text)))
- (puthash ebib-current-field text ebib-cur-entry-hash)))
- ((eq ebib-editing 'strings)
- (if (equal text "")
- ;; with ERROR, we avoid execution of EBIB-SET-MODIFIED and
- ;; MESSAGE, but we also do not switch back to the strings
- ;; buffer. this may not be so bad, actually, because the user
- ;; may want to change his edit.
- (error "@STRING definition cannot be empty ")
- (setq text (from-raw text)) ; strings cannot be raw
- (puthash ebib-current-string text (edb-strings ebib-cur-db))))))
- (ebib-set-modified t))
-
-(defun ebib-cancel-multiline-edit ()
- "Quits the multiline edit buffer and discards the changes."
- (interactive)
- (catch 'no-cancel
- (when (buffer-modified-p)
- (unless (y-or-n-p "Text has been modified. Abandon changes? ")
- (throw 'no-cancel nil)))
- (cond
- ((eq ebib-editing 'fields)
- (switch-to-buffer ebib-entry-buffer)
- (ebib-redisplay-current-field)) ; we have to do this, because the
- ; user may have saved with C-x C-s
- ; before
- ((eq ebib-editing 'strings)
- (switch-to-buffer ebib-strings-buffer)
- (ebib-redisplay-current-string))
- ((eq ebib-editing 'preamble)
- (switch-to-buffer ebib-entry-buffer)
- (other-window 1)))))
-
-;;;;;;;;;;;;;;;;;;;;
-;; ebib-help-mode ;;
-;;;;;;;;;;;;;;;;;;;;
-
-(defvar ebib-help-mode-map
- (let ((map (make-keymap 'ebib-help-mode-map)))
- (suppress-keymap map)
- (define-key map " " 'scroll-up)
- (define-key map "b" 'scroll-down)
- (define-key map "q" 'ebib-quit-help-buffer)
- map)
- "Keymap for the ebib help buffer.")
-
-(define-derived-mode ebib-help-mode
- fundamental-mode "Ebib-help"
- "Major mode for the Ebib help buffer."
- (setq buffer-read-only t)
- (local-set-key "\C-xb" 'ebib-quit-help-buffer)
- (local-set-key "\C-xk" 'ebib-quit-help-buffer))
-
-(defun ebib-display-help (buffer)
- "Shows the help message for Ebib-buffer BUFFER."
- (switch-to-buffer ebib-help-buffer)
- (setq ebib-before-help buffer)
- (with-buffer-writable
- (erase-buffer)
- (cond
- ((eq buffer ebib-index-buffer) (insert ebib-index-buffer-help))
- ((eq buffer ebib-entry-buffer) (insert ebib-entry-buffer-help))
- ((eq buffer ebib-strings-buffer) (insert ebib-strings-buffer-help)))
- (goto-char (point-min))))
-
-(defun ebib-quit-help-buffer ()
- "Exits the help buffer."
- (interactive)
- (cond
- ((eq ebib-before-help ebib-index-buffer)
- (switch-to-buffer ebib-entry-buffer)
- (other-window 1))
- ((eq ebib-before-help ebib-entry-buffer)
- (switch-to-buffer ebib-entry-buffer))
- ((eq ebib-before-help ebib-strings-buffer)
- (switch-to-buffer ebib-strings-buffer))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; functions for non-Ebib buffers ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defun ebib-import ()
- "Searches for BibTeX entries in the current buffer.
-
-The entries are added to the current database (i.e. the database that was
-active when Ebib was lowered. Works on the whole buffer, or on the region
-if it is active."
- (interactive)
- (if (not ebib-cur-db)
- (error "No database loaded. Use `o' to open a database")
- (if (edb-virtual ebib-cur-db)
- (error "Cannot import to a virtual database")
- (save-excursion
- (save-restriction
- (if (region-active)
- (narrow-to-region (region-beginning)
- (region-end)))
- (let ((text (buffer-string)))
- (with-temp-buffer
- (insert text)
- (let ((n (ebib-find-bibtex-entries t)))
- (setf (edb-keys-list ebib-cur-db) (sort (edb-keys-list ebib-cur-db) 'string<))
- (setf (edb-n-entries ebib-cur-db) (length (edb-keys-list ebib-cur-db)))
- (when (edb-strings-list ebib-cur-db)
- (setf (edb-strings-list ebib-cur-db) (sort (edb-strings-list ebib-cur-db) 'string<)))
- (setf (edb-cur-entry ebib-cur-db) (edb-keys-list ebib-cur-db))
- (ebib-fill-entry-buffer)
- (ebib-fill-index-buffer)
- (ebib-set-modified t)
- (message (format "%d entries, %d @STRINGs and %s @PREAMBLE found in buffer."
- (car n)
- (cadr n)
- (if (caddr n)
- "a"
- "no")))))))))))
-
-(defun ebib-extract-bibfile ()
- (save-excursion
- (goto-char (point-min))
- (when (re-search-forward "\\\\bibliography{\\(.*?\\)}" nil t)
- (ensure-extension
- (buffer-substring-no-properties (match-beginning 1) (match-end 1))
- "bib"))))
-
-(defun ebib-get-db-from-filename (filename)
- "Returns the database struct associated with FILENAME."
- (catch 'found
- (mapc '(lambda (db)
- (if (string= (file-name-nondirectory (edb-filename db)) filename)
- (throw 'found db)))
- ebib-databases)
- nil))
-
-(defun ebib-get-local-database ()
- "Returns the database associated with the LaTeX file in the current buffer.
-
-If there is no \\bibliography command, return the current database."
- (unless ebib-local-bibtex-filename
- ;; if we don't know the .bib file yet, try to find it.
- (if (and (boundp 'TeX-master)
- (stringp TeX-master))
- ;; if AucTeX's TeX-master is used and set to a string, we must
- ;; search that file for a \bibliography command, as it's more
- ;; likely to be in there than in the file we're in.
- (let ((texfile (ensure-extension TeX-master "tex")))
- (if (file-readable-p texfile)
- (let ((bibfile nil))
- (with-temp-buffer
- (insert-file-contents texfile)
- ;; we can only set ebib-local-bibtex-filename after the
- ;; temp buffer is killed. so we store it temporarily.
- (setq bibfile (ebib-extract-bibfile)))
- (setq ebib-local-bibtex-filename bibfile))))
- ;; and otherwise just search the current file.
- (setq ebib-local-bibtex-filename (ebib-extract-bibfile))))
- (if (null ebib-local-bibtex-filename) ; if we still don't have a bibtex filename...
- (progn
- (message "No \\bibliography command found. Using current database.")
- ebib-cur-db)
- (ebib-get-db-from-filename ebib-local-bibtex-filename)))
-
-(defun ebib-insert-bibtex-key (prefix)
- "Inserts a BibTeX key at POINT, surrounded by braces.
-
-The user is prompted for a BibTeX key and has to choose one from the
-database of the current LaTeX file, or from the current database if there
-is no \\bibliography command. Tab completion works."
- (interactive "p")
- (if (null ebib-databases)
- (error "No database loaded")
- (let ((db (ebib-get-local-database)))
- (cond
- ((null db)
- (error "Database %s not loaded." ebib-local-bibtex-filename))
- ((= (hash-table-count (edb-database db)) 0)
- (error "No entries in database %s" ebib-local-bibtex-filename))
- (t
- (let* ((collection (ebib-create-collection (edb-database db)))
- (key (completing-read "Key to insert: " collection nil t nil ebib-minibuf-hist)))
- (when key
- (insert (format (or (cdr (assoc prefix ebib-insertion-strings))
- "{%s}") key)))))))))
-
-(defun ebib-entry-summary ()
- "Shows the fields of the key at POINT.
-
-The key is searched in the database associated with the LaTeX file, or in
-the current database if no \\bibliography command can be found."
- (interactive)
- (if (null ebib-databases)
- (error "No database loaded")
- (let ((db (ebib-get-local-database))
- (key (read-string-at-point "\"#%'(),={} \n\t\f")))
- (cond
- ((null db)
- (error "Database %s not loaded" ebib-local-bibtex-filename))
- ((not (member key (edb-keys-list db)))
- (error "`%s' is not in database `%s'" key ebib-local-bibtex-filename))
- (t
- (with-output-to-temp-buffer "*Help*"
- (let* ((entry (gethash key (edb-database db))))
- (ebib-format-fields entry 'princ))))))))
-
-(provide 'ebib)
-
-;; we put these at the end, because they seem to mess up Emacs'
-;; syntax highlighting.
-
-(setq ebib-index-buffer-help
- "Ebib index buffer -- command key overview
-
-When no database is open, only the commands marked with * are available.
-
-Note: command keys are case-sensitive.
-
-(Press C-v to scroll down, M-v to scroll up, `q' to quit.)
-
-cursor movement:
-[up], k, C-p: go to the previous entry
-[down], j, C-n: go to the next entry
-[home], g: go to the first entry
-[end], G: go to the last entry
-[PgUp], b, M-p: scroll 10 entries up
-[PgDn], [space], M-n: scroll 10 entries down
-
-editing:
-e: edit the current entry
-E: edit the current entry's name
-a: add a new entry
-d: delete the current entry
-t: edit the @STRING definitions
-p: edit the @PREAMBLE definition
-
-searching:
-/: search the database
-n: find the next occurrence of the search string
-C-s: search for a key (incrementally)
-[return]: select the entry under the cursor (use after C-s)
-&: filter the current database with a logical AND
-|: filter the current database with a logical OR
-~: filter the current database with a logical NOT
-V: show the current filter (with prefix argument:
- reapply current filter)
-
-file handling:
-o*: open a database
-c: close the database
-s: save the database
-S: save all databases
-w: save the database under a different name
-M: merge another database
-x: export the current entry to another file
- (with prefix argument N: copy to database N)
-X: export the @PREAMBLE definition to another file
- (with prefix argument N: copy to database N)
-f: print the full filename in the minibuffer
-
-databases:
-1-9: switch to database 1-9
-J: switch to another database (accepts prefix argument)
-[right], [left]: switch previous/next database
-P: print the database
-L: LaTeX the database
-
-general:
-C: customise Ebib
-z*: put Ebib in the background
-q*: quit Ebib
-h*: show this help page
-")
-
-(setq ebib-entry-buffer-help
- "Ebib entry buffer -- command key overview
-
-Note: command keys are case-sensitive.
-
-(Press C-v to scroll down, M-v to scroll up, `q' to quit.)
-
-cursor movement:
-[up], k, C-p: go to the previous field
-[down], j, C-n: go to the next field
-[home], g: go to the first field
-[last], G: go to the last field
-[PgUp], b, M-p: go to the previous group of fields
-[PgDn], [space], M-n: go to the next group of fields
-
-editing:
-e: edit the value of the current field
-c: copy the value of the current field (value is put into the kill ring)
-x: kill the value of the current field (value is put into the kill ring)
-y: yank the most recently copied/cut string
-d: delete the value of the current entry
-r: toggle the \"rawness\" status of the current field
-l: edit the current field as multi-line
-s: insert an @STRING abbreviation into the current field
-
-general:
-q: quit the entry buffer and return to the index buffer
-h: show this help page
-")
-
-(setq ebib-strings-buffer-help
- "Ebib strings buffer -- command key overview
-
-Note: command keys are case-sensitive.
-
-(Press C-v to scroll down, M-v to scroll up, `q' to quit.)
-
-cursor movement:
-[up], k, C-p: go to the previous @STRING definition
-[down], j, C-n: go to the next @STRING definition
-[home], g: go to the first @STRING definition
-[end], G: go to the last @STRING definition
-[PgUp], b, M-p: scroll 10 @STRING definitions up
-[PgDn], [space], M-n: scroll 10 @STRING definitions down
-
-editing:
-e: edit the value of the current @STRING definition
-c: copy the value of the current @STRING definition
-d: delete the current @STRING definition
-a: add an @STRING definition
-l: edit the current @STRING as multi-line
-
-exporting:
-x: export the current @STRING definition to another file
- (with prefix argument N: copy to database N)
-X: export all @STRING definitions to another file
- (with prefix argument N: copy to database N)
-
-general:
-q: quit the strings buffer and return to the index buffer
-h: show this help page
-tt")
-
-;;; ebib ends here
projects / lib.git / blobdiff