; -*- Mode:Emacs-Lisp -*-
;
; $Id: rolodex.el,v 1.5 1995/04/06 14:55:06 waider Exp waider $
;
; Update History
;    08/94 Wrote the thing.
; 22/11/94 Added SPACE and DEL keymappings (as requested by Stepen!)
;   /01/95 Playing with an edit facility
; 15/02/95 (stephen) Added edit mode
; 06/04/95 (waider) Redid indexing, some code formatting also
;                   added delete, handling for empty files,
;                   (rolo "filename") now works, tweaked variable names

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Variables
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar rolo-dir "~/rolodex/" "Default search directory for rolo files")
(defvar rolo-file-default "~/rolodex/notes.xrolo" "Default rolo to open")
(defvar rolo-mode 'text-mode "Rolodex mode")
(defvar rolo-index-mode 'text-mode "Rolodex index mode")
(defvar rolo-file nil "Current rolodex filename *do not alter!*")
(defvar rolo-buffer nil "Current rolodex buffer name *do not alter!*")
(defvar rolo-index-list nil "Rolodex index list")
(defvar rolo-index-item nil "Item number in index")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Keymaps
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar rolo-map
  (let ((map (make-keymap)))
    (define-key map "i" 'rolo-index)
    (define-key map "q" 'rolo-index)
    (define-key map "\r" 'next-line)
    (define-key map "e" 'rolo-edit)
    (define-key map "d" 'rolo-delete)
					; These don't work very well!
    (define-key map " " 'forward-page)
    (define-key map "\C-?" 'backward-page)
    map)
  "Rolodex keymap")

(defvar rolo-index-map
  (let ((map (make-keymap)))
    (define-key map "\r" 'rolo-goto-card)
    (define-key map "e" 'rolo-goto-card-and-edit)
    (define-key map "d" 'rolo-goto-card-and-delete)
    (define-key map "q" 'rolo-quit)
    (define-key map " " 'next-line)
    (define-key map "\C-?" 'previous-line)
    (define-key map "n" 'rolo-new)
    map)
  "Rolodex index keymap")

(defvar rolo-edit-map
  (let ((map (make-keymap)))
    (define-key map "\C-c\C-c" 'rolo-edit-quit)
    map)
  "Rolodex Edit keymap")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; --------------- code starts here ------------------------------------------ ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo() - Top level defun
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo (&optional filename) "Run rolodex"
  (interactive)
  ; FIXME does specifying the filename above actually work??
  (setq rolo-file 
	(or filename 
	    (read-file-name "Open rolodex: " (expand-file-name rolo-dir)
			    (expand-file-name rolo-file-default) nil)))
  (find-file rolo-file)
  (beginning-of-buffer)

  ; Set the mode line and maps for the buffer
  (setq major-mode 'rolo-mode
	mode-name "Rolodex"
	buffer-read-only t)
  (use-local-map rolo-map)
  (setq rolo-buffer (current-buffer))

  ; Generate the index buffer
  (rolo-make-index))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-make-index() - generates an index buffer from rolo-buffer
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-make-index () "Create an index for the current rolodex file"
  (interactive)

  ; Clear the index list
  (setq rolo-index-list nil)
  (setq rolo-index-item 1)

  ; Set up buffer, erase it in case it already exisits
  (set-buffer (get-buffer-create "*rolodex index*"))
  (setq buffer-read-only nil)
  (setq rolo-index-buffer (current-buffer))
  (erase-buffer)

  ; Set up the rolo-buffer for indexing, save size of buffer in rolo-end
  (set-buffer rolo-buffer)
  (widen)
  (end-of-buffer)
  (setq rolo-end (point))
  (beginning-of-buffer)

  ;; Could most likely rewrite this section to use buffer-substring?
  (while (re-search-forward "^####\n" rolo-end t)
    (setq start (point))
    (end-of-line)
    (forward-char) ; pick up newline...
	       
    ; Now stuck the selected expression into rolo-index-list
    (setq rolo-index-list 
	  (cons start rolo-index-list))
	       
    ; Add stuff to the rolodex index buffer
    (save-excursion 
      (set-buffer rolo-index-buffer)
      (insert (format "%4d. " rolo-index-item)))
    (append-to-buffer "*rolodex index*" start (point))

    ; Need to increment the line pointer too.
    (setq rolo-index-item (+ 1 rolo-index-item)))

  ; List needs to be reversed now
  (setq rolo-index-list (reverse rolo-index-list))

  ; Switch to the index buffer & set modeline and keymap
  (switch-to-buffer "*rolodex index*" t)
  (and (> rolo-index-item 1)
       (progn (backward-delete-char 1)  ; Trim last newline off index buffer
	      (goto-char 6)))
  (make-variable-buffer-local 'goal-column)
  (setq major-mode 'rolo-index-mode
	mode-name "Rolodex-index"
	buffer-read-only t
	goal-column 5)
  (use-local-map rolo-index-map))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-index() - switch to rolodex index buffer
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-index () "Switch to the index"
  (interactive)
  (if (get-buffer "*rolodex index*")
      (switch-to-buffer "*rolodex index*" t)
    (rolo-make-index)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-goto-card() - goto the selected card
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-goto-card () "Go to the selected card"
  (interactive)

  (if (not (car rolo-index-list))
      (message "No cards in file")
    ; else
    (progn

      ; Find out where the pointer is
      (save-excursion (set-buffer "*rolodex index*")
		      (beginning-of-line)
		      (setq start (point))
		      (end-of-line)
		      (setq string (buffer-substring start (point))))
      
      ; Set up card buffer
      (switch-to-buffer rolo-buffer)
      (widen)
      (beginning-of-buffer)

      ; Now find the card
      (setq start (nth (- (string-to-int string) 1) rolo-index-list))
      (narrow-to-region start (point-max))
      (if (re-search-forward "^####\n" (point-max) t)
	  (backward-char 5)
        ;else
	(end-of-buffer))
      (narrow-to-region start (point))
      (beginning-of-buffer))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-quit() - delete buffers on exit
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-quit () "Quit Rolodex mode"
  (interactive)
  (kill-buffer "*rolodex index*")
  (kill-buffer rolo-buffer))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-edit() - switch to editing mode
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-edit () "Edit a rolodex card"
  (interactive)
  (setq buffer-read-only nil
	mode-name "Rolodex-Edit"
	major-mode 'text-mode)
  (use-local-map rolo-edit-map)

  (message "Do C-c C-c to exit edit"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-edit-quit() - get out of editing mode
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-edit-quit () "Quit rolo edit!"
  (interactive)

  (save-excursion
    (end-of-buffer)
    (or (= (point) (point-min))
	(forward-char -1))

    (if (not (looking-at "\n"))
	(progn
	  (end-of-buffer)
	  (insert "\n"))))
  
  (save-buffer)
  (setq buffer-read-only t
	mode-name "Rolodex"
	major-mode 'rolo-mode)
  (use-local-map rolo-map)
  (rolo-make-index))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-delete() - delete the current card
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-delete () "Delete the current card"
  (interactive)
  (setq buffer-read-only nil)
  (kill-region (point-min) (point-max))
  (widen)
  (and (re-search-backward "^####\n" (point-min) t)
       (kill-line))
  (save-buffer)
  (rolo-make-index))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-goto-card-and-edit() - edit an existing card
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-goto-card-and-edit () "Edit a card from the index"
  (interactive)
  (if (not (car rolo-index-list))
      (message "No cards in file")
    ; else
    (progn
      (rolo-goto-card)
      (rolo-edit))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-goto-card-and-delete() - delete an existing card
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-goto-card-and-delete () "Delete a card from the index"
  (interactive)
  (if (not (car rolo-index-list))
      (message "No cards in file")
    ; else
    (progn
      (rolo-goto-card)
      (rolo-delete))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; rolo-new() - add a new card to the rolodex
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun rolo-new () "Append a card to the current buffer"
  (interactive)

  (switch-to-buffer rolo-buffer)
  (widen)
  (end-of-buffer)
  (setq buffer-read-only nil)
  (insert "####\n")
  (narrow-to-region (point) (point))
  (rolo-edit))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;