;;; electric-latin1-mode.el
;;; Minor mode to insert ISO-Latin 1 codes in place of 2-character
;;; sequences on keyboards lacking latin1 capabilities.

;;; Author: Marc Shapiro <shapiro@sor.inria.fr> 5-dec-94

;;; add this to your .emacs:
;;; (autoload 'electric-latin1-mode
;;; 	  "electric-latin1-mode"
;;; 	  "Minor mode for inputting accents on keyboards lacking them"
;;; 	  t nil)
;;; (add-hook 'text-mode-hook
;;; 	  '(lambda ()
;;;          ... your stuff ...
;;; 	     (electric-latin1-mode 0) ;;; !!! do not omit
;;; 	     (define-key (current-local-map) "\C-c\C-v" 'electric-latin1-mode)
;;;	     )))
;;;  (add-hook 'rmail-mode-hook
;;; 	   '(lambda ()
;;;           ... your stuff ...
;;; 	      (define-key rmail-mode-map "\C-c\C-v" 'electric-latin1-mode)
;;; 	       ))

(provide 'electric-latin1-mode)

;;Add minor mode to minor-mode-alist
(or (assq 'electric-latin1-mode minor-mode-alist)
    (setq minor-mode-alist (cons '(electric-latin1-mode " ELT1")
                                 minor-mode-alist)))

(defun electric-latin1-mode (arg)
  "Minor mode for inputting accented characters on keyboards lacking them.
The characters \'`^#¨, are translated into acute, grave, diaresis, circumflex
and cedille, when associated with the appropriate characters.  The recognized
combinations correspond to the regexp:
	 a[`^]\\|e[\'`^#¨]\\|i[#¨^]\\|o^\\|u[`#¨^]\\|c,[aou]
With no argument, toggle electric-latin1-mode.  With arg turn on
electric-latin1-mode, with zero or negative arg turn electric-latin1-mode off"
  (interactive "P")
  (cond ((not (boundp 'electric-latin1-mode)) ; not bound: intialize
	 (make-variable-buffer-local 'electric-latin1-mode)
	 (set-default 'electric-latin1-mode nil)
	 (global-set-key "\'" 'ell1-acute-or-apostrophe)
         (global-set-key "`" 'ell1-grave-or-backquote)
         (global-set-key "^" 'ell1-circumflex-or-caret)
         (global-set-key "a" 'ell1-hard-vowel)
         (global-set-key "o" 'ell1-hard-vowel)
         (global-set-key "u" 'ell1-hard-vowel)
         (global-set-key "A" 'ell1-hard-vowel)
         (global-set-key "O" 'ell1-hard-vowel)
         (global-set-key "U" 'ell1-hard-vowel)
         (global-set-key "#" 'ell1-diaresis-or-pound)
         (global-set-key "¨" 'ell1-diaresis-or-pound)
	 (global-set-key "\"" 'ell1-double-quote)
	 ))
  (if arg
      (setq electric-latin1-mode (or (listp arg) ;; C-u alone
				    (> (prefix-numeric-value arg) 0)))
    (setq electric-latin1-mode (not electric-latin1-mode)))
  )

(defun ell1-acute-or-apostrophe (count)
  "When electric-latin1-mode is on, put acute accent or insert
apostrophe, depending on preceding characters.  With arg, self-insert."
  (interactive "P")
  (if (and electric-latin1-mode (not count))
      (let ((prec (preceding-char)))
	(cond (( = prec ?e)	; e' is eacute
	       (delete-char -1)
	       (insert-char ?\351 1))
	      (( = prec ?\351) ; e'' is e-'-'
	       (delete-char -1)
	       (insert "e''"))
	      (( = prec ?E)	; E' is Eacute
	       (delete-char -1)
	       (insert-char 201 1))
	      (( = prec 201) ; E'' is E-'-'
	       (delete-char -1)
	       (insert "E''"))
	      ((and ( = prec ?')
		    ( >= ( - (point) (point-min)) 3 ))
	       (forward-char -3)
	       (cond ((looking-at "e''") ; e''' is eacute-'-'
		      (delete-char 1)
		      (insert-char ?\351 1)
		      (forward-char 2))
		     ((looking-at "E''") ; E''' is Eacute-'-'
		      (delete-char 1)
		      (insert-char 201 1)
		      (forward-char 2))
		     (t
		      (forward-char 3)
		      (self-insert-command (prefix-numeric-value count)))))

	      (t
	       (self-insert-command (prefix-numeric-value count)))))
    (self-insert-command (prefix-numeric-value count))))

(defun ell1-replace-prec-or-self-insert (count alist)
  "If COUNT is nil and (preceding-char) is found in association list ALIST,
replace it; else self-insert"
  (if (and electric-latin1-mode (not count))
      (let ((repl (assoc (preceding-char) alist)))
	(cond (repl
	       (delete-char -1)
	       (insert-char (cdr repl) 1))
	      (t
	       (self-insert-command 1))))
    (self-insert-command (prefix-numeric-value count))))

(defun ell1-grave-or-backquote (count)
  "When electric-latin1-mode is on, put grave accent or insert backquote,
depending on preceding character.  With arg, self-insert."
  (interactive "P")
  (ell1-replace-prec-or-self-insert count
				    '((?a . ?\340)
				      (?e . ?\350)
				      (?u . ?\371)
				      (?A . 192)
				      (?E . 200)
				      (?U . 217))))

(defun ell1-circumflex-or-caret (count)
  "When electric-latin1-mode is on, put circumflex accent or insert
caret, depending on preceding character.  With arg, self-insert."
  (interactive "P")
  (ell1-replace-prec-or-self-insert count
				    '((?i . ?\356)
				      (?a . ?\342)
				      (?e . ?\352)
				      (?o . ?\364)
				      (?u . ?\373)
				      (?I . 206)
				      (?A . 194)
				      (?E . 202)
				      (?O . 212)
				      (?U . 219))))

(defun ell1-hard-vowel (count)
  "When electric-latin1-mode is on, self-insert, but first check if preceding
characters do not form c-cedille.  With arg, self-insert."
  (interactive "P")
  (cond ((and electric-latin1-mode
	      (>= (- (point) 2) (point-min)))
	 (forward-char -2)
	 (cond ((looking-at "c,")
		(delete-char 2)
		(insert-char 231 1))
	       ((looking-at "C,")
		(delete-char 2)
		(insert-char 199 1))

	       (t
		(forward-char 2))))
	(t t))
  (self-insert-command (prefix-numeric-value count)))

(defun ell1-diaresis-or-pound (count)
  "When electric-latin1-mode is on, put diaresis accent or self-insert,
depending on preceding character.  With arg, self-insert."
  (interactive "P")
  (ell1-replace-prec-or-self-insert count
				    '((?e . ?\353)
				      (?u . ?\374)
				      (?i . ?\357)
				      (?E . 203)
				      (?U . 220)
				      (?I . 207))))

(defun ell1-double-quote (count)
  "When electric-latin1-mode is on, insert guillemet (left or right) instead of
double-quote.  With arg, self-insert."
  (interactive "P")
  (if (and electric-latin1-mode (not count))
      (cond
       ((or (bolp)
	    (save-excursion
	      (forward-char -1)
	      (looking-at "\\ ")))
	(insert-char 171 1))		; guillemet left
       (t
	(insert-char 187 1)		; guillemet right
	))
    (self-insert-command (prefix-numeric-value count))))