;; .emacs - Copyright (C) 1994-2000 Pat Thoyts <pat@zsplat.freeserve.co.uk>
;;
;; This is my joint FSF Emacs and XEmacs configuration file.
;;

(defconst _emacs-version
  "@(#)$Id: _emacs,v 1.22 2000/11/19 18:25:57 pat Exp $"
  "RCS version of my .emacs file.")

;;
;; Define some variables for version specific section in this file.
;;
(defconst running-xemacs (string-match "XEmacs\\|Lucid" emacs-version)
  "Set if this is a version of XEmacs")
(defconst running-win32 (eq 'windows-nt system-type)
  "Set t if we are using a win32 compiled version of emacs.")
(defconst at-renishaw 
  (if (string-match "pt111992" (user-login-name))
      t
    nil)
  "Set t if we are logged in at Renishaw.")

(defconst emacsdir
  (let ((file (file-name-sans-versions (file-name-directory data-directory))))
    (cond ((string-match "/etc" file)
           (substring file 0 (match-beginning 0)))
          ((string-match "\\etc" file)
           (substring file 0 (match-beginning 0)))
          (t
           nil)) )
  "The pathname of the emacs installation in use.
We can't seem to use `installation-directory' as it's come out nil. However,
working from the `data-directory' works fine.")

(defsubst pat-vboundp (symbol)
  "Like fboundp. Return true if SYMBOL has been defined."
  (if (condition-case () (symbol-value symbol) (error nil))
      t
    nil))

;; version checking (from XEmacs sample .emacs file).
(if (and (not (boundp 'emacs-major-version))
         (string-match "^[0-9]+" emacs-version))
    (setq emacs-major-version
          (string-to-int (substring emacs-version
                                    (match-beginning 0) (match-end 0)))))
(if (and (not (boundp 'emacs-minor-version))
         (string-match "^[0-9]+\\.\\([0-9]+\\)" emacs-version))
    (setq emacs-minor-version
          (string-to-int (substring emacs-version
                                    (match-beginning 1) (match-end 1)))))
(defun running-emacs-version-or-newer (major minor)
  (or (> emacs-major-version major)
      (and (= emacs-major-version major)
           (>= emacs-minor-version minor))))

;; XEmacs suggests using this function - but it's not in all versions...
(if (not (fboundp 'console-type))
    (defun console-type () window-system "Replace XEmacs function."))
(if (not (fboundp 'char-int))
    (defun char-int (arg)
      "Substitute for the XEmacs char-int function."
      (cond
       ((sequencep arg) (aref arg 1))
       ((char-or-string-p arg) arg )
       (t (error "Not a char or string object")))))

;; Try and start gnuserv if possible, otherwise go for emacsserv.
;; Careful, they might already be started.
(cond
 ((or (featurep 'gnuserv)  ; skip loading if it's been done already, 
      (featurep 'server))  ; like in site-start.el or something.
  nil)
 ((condition-case () (require 'gnuserv) (error nil))
  (message "server: uses gnuclient.")
  (setq gnuserv-frame (selected-frame))
  (if (not running-xemacs)
      (gnuserv-start)))
 ((condition-case () (require 'server) (error nil))
  (message "server: uses emacsclient")
  (server-start)
  (setq server-temp-file-regexp
        (concat "\\(" server-temp-file-regexp "\\)"
                "\\|\\(^/scratch/__ED[0-9]+$\\)"
                "\\|\\(_PH_/__EMACS__[0-9]+$\\)")))
 (t
  (message "No server available.")))

;; Add personal lisp package directories.
(if (file-readable-p "~/lib/lisp")
    (add-to-list 'load-path "~/lib/lisp"))
(if (and running-win32
         (not (string-match "[Mm]:" (getenv "HOME")))
         (file-readable-p "m:/lib/lisp"))
    (add-to-list 'load-path "m:/lib/lisp"))

;; Don't move the next two functions into another large library. They should
;; go here. (Unless it's a teeny library, hence quick).

;;;Bah! Snipped from FSF Emacs to cope with XEmacs lack.
(if (not (fboundp 'file-name-extension))
    (defun file-name-extension (filename &optional period) ""
      (save-match-data
        (let ((file (file-name-sans-versions 
                     (file-name-nondirectory filename))))
          (if (string-match "\\.[^.]*\\'" file)
              (substring file (+ (match-beginning 0) (if period 0 1)))
            (if period
                ""))))))

(defun pat-locate-library (file)
  "Get the expanded file name for FILE by looking through the `load-path'.
It also looks at the current directory first, which may or may not be right.
Returns either the full path or nil.
Bound to \\[pat-locate-library]"
  (interactive "sLibrary name:")
  (let ((path file)
	(i 0))
    (if (not (file-name-extension file))
        (setq file (concat file ".el")))
    (while (and (elt load-path i)
		(not (file-exists-p path)))
      (setq path (expand-file-name (concat (elt load-path i) "/" file)))
      (setq i (1+ i)))
    (if (interactive-p)
	(message "%s" path))
    (if (file-exists-p path)
	path
     nil)))

(defun pat-cond-recompile-file (file)
  "If a compiled version of FILE exists and is older than FILE, recompile it.
Bound to \\[pat-cond-recompile-file]"
  (interactive "fEmacs Lisp File : ")
  (if (not file)
      nil
    (let ((elc (concat (file-name-sans-extension file) ".elc")))
      (if (file-newer-than-file-p file elc)
          (progn
            (message (concat "please standby: recompiling " file "..."))
            (sit-for 1)
            (byte-compile-file file)
            (message (concat file " recompiled")))))))

;; We are using FSF and XEmacs interchangeably, but we need different byte
;; codes for each. Try this way:
(cond
 (running-xemacs
  (pat-cond-recompile-file (pat-locate-library "patfuncx"))
  (require 'patfuncx))
 (t
  (pat-cond-recompile-file (pat-locate-library "patfunc"))
  (require 'patfunc)) )

(condition-case () (require 'time)      (error nil))
(condition-case () (require 'font-lock) (error nil))
(condition-case () (require 'cc-mode)   (error nil))
(condition-case () (require 'calendar)  (error nil))
(condition-case () (require 'appt)      (error nil))

;; Put the time on the status bar.
(if (or (featurep 'time)
        (fboundp 'display-time))
    (display-time))
(if (and (featurep 'calendar)
         (featurep 'appt)
         (file-readable-p (substitute-in-file-name diary-file)))
    (progn
      (add-hook 'diary-hook 'appt-make-list)
      (diary 4)))

;;
;; Get font lock on all the time...
;;
(if (fboundp 'global-font-lock-mode) ;; not in XEmacs
	(global-font-lock-mode t))
(setq font-lock-use-default-colors t)
(setq font-lock-maximum-decoration t)
(setq font-lock-auto-fontify t)

;;
;; I had some trouble with mail name and full name (on SunOS-5.5.1 on pennard)
;; so re-jigged it here.
;; We also fix my pgp-user-id here for mailcrypt.
;;

(defvar ISP nil
  "*Default Internet Service Provider.

We could be using one of a number if ISPs especially under win32.
This is to control which is used by .emacs.  You should set this and
probably just run `pat-set-isp' (\\[pat-set-isp]) to set the relevant
site names before you send anything anyway.")

(setq mail-host-address "zsplat.freeserve.co.uk")
(setq user-mail-address "pat@zsplat.freeserve.co.uk")
(setq pat-home-page "http://www.zsplat.freeserve.co.uk/")
;(if (pat-vboundp 'user-full-name) ;; not defined under XEmacs
(setq user-full-name "Pat Thoyts")
(if (not (fboundp 'user-full-name))
    (defun user-full-name () user-full-name))
(setq mail-default-reply-to user-mail-address)
(cond 
 ((pat-vboundp 'message-required-mail-headers)
  (add-to-list 'message-required-mail-headers (cons 'X-Face pat-x-face))
  (add-to-list 'message-required-mail-headers (cons 'X-Url pat-home-page))))
(pat-set-isp "freeserve")

;; Mail stuff. Under win32 do the mail transfers ourselves.
(cond
 ((and running-win32
       (locate-library "feedmail")
       (locate-library "smtpmail"))
  (autoload 'feedmail-send-it "feedmail")
  (autoload 'feedmail-run-the-queue "feedmail")
  (autoload 'feedmail-run-the-queue-no-prompts "feedmail")
  (setq send-mail-function 'feedmail-send-it)
  (setq feedmail-buffer-eating-function 'feedmail-buffer-to-smtpmail)
  (setq feedmail-enable-queue t)   ; queue mail
  (setq feedmail-queue-chatty nil) ; optional
  (setq auto-mode-alist (cons '("\\.fqm$" . mail-mode) auto-mode-alist))  
  (load-library "message")
  (setq message-send-mail-function 'smtpmail-send-it)
  ))

;; GNUS news settings.
;; The groups buffer display style
(setq gnus-carpal nil ;; use buttons too?
      gnus-group-line-format "%M%S%4y,%4t: %(%c%)\t%(%D%)\n"
      gnus-check-new-newsgroups nil
      gnus-secondary-select-methods '((nnmh "private")) ;; read mail too.
      nnmail-spool-file "/var/spool/mail/pat"
      nnmail-split-methods '(("inbox" ""))
      nnmh-get-new-mail t               ;; fetch mail
      nnmh-be-safe t                    ;; be real safe (for now)
      gnus-read-active-file nil) ; to stop it getting the active list
;(cond (running-xemacs
;       (setq gnus-use-picons nil)
;       (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t)
;       (add-hook 'gnus-summary-prepare-hook 'gnus-group-display-picons t)
;       (add-hook 'gnus-article-display-hook
;                 'gnus-picons-article-display-x-face)))
(add-hook 'gnus-started-hook 'pat-news-address-hook)
(add-hook 'gnus-after-exiting-gnus-hook
          (lambda nil "" nil 
            (setq user-mail-address (pat-rot13-string user-mail-address))))
(setq browse-url-browser-function 'browse-url-w3)


;; Use Mailcrypt if we have it for GNUS and MH-E and mail-mode
(if (and (condition-case () (require 'mailcrypt) (error nil))
         (fboundp 'mc-install-write-mode))
    (progn
      (message "Configuring Mailcrypt for use with gnus.")
      (autoload 'mc-install-write-mode "mailcrypt" nil t)
      (autoload 'mc-install-read-mode "mailcrypt" nil t)
      (add-hook 'mail-mode-hook 'mc-install-write-mode)
      (add-hook 'news-reply-mode-hook 'mc-install-write-mode)
      (add-hook 'message-mode-hook 'mc-install-write-mode)
      (add-hook 'gnus-summary-mode-hook 'mc-install-read-mode)
      (add-hook 'mh-folder-mode-hook 'mc-install-read-mode)
      (add-hook 'mh-letter-mode-hook 'mc-install-write-mode)
      (setq mc-pgp-comment nil  ;; no extra comment field.
            gnus-use-mailcrypt t
            mc-pgp-user-id (user-full-name))))

;;
;; Sound support is system dependent.ie: only porky can do it at the moment.
;; However, I'll allow it for linux systems.
;;
(cond ((string-match "pennard" (system-name))
       (message "Skipping sound configuration on host %s." (system-name)) )
      ((and running-win32
            running-xemacs)
       (autoload 'load-default-sounds "sound" "Get XEmacs Sound Support" t)
       (load-default-sounds)
       (setq file "/usr/local/lib/sounds/bark.au")
       (if (file-readable-p file)
           (load-sound-file file  'bark))
       (setq file "/usr/local/lib/sounds/borg1.au")
       (if (file-readable-p file)
           (load-sound-file file  'borg 20)) )
      (running-xemacs
       (setq bell-volume 40)
       (setq sound-alist
	     (append sound-alist '((no-completion :pitch 500)))))
      (t
       (setq bell-volume 40)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Some general settings.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(put 'downcase-region 'disabled nil)
(setq line-number-mode t)
(setq text-mode-hook 'turn-on-auto-fill)
(setq make-backup-files nil)
(if (fboundp 'set-language-environment)
    (set-language-environment 'Latin-1))
(setq european-calendar-style t)
(setq transient-mark-mode t)
(if (featurep 'hscroll) (hscroll-global-mode t))
;;(setq lp-switches "-P hrclaser1") ;; colour on?
(setq completion-ignore-case t)  ;; Try this for lazy filename completion.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Info path. This should add onto the stuff in INFOPATH.
;; There seems to all sorts of trouble with this depending upon whether
;; we are using GNU or X emacs. The path seems OK - it's the use of the
;; dir files.
;;
;;(setq Info-directory-list
;;      (append Info-directory-list '("/usr/local/info"
;;				    "/home/usera/thoytsp/lib/info")))

;; Autoload functions and modes. First the version specific ones.
(cond
 (running-xemacs
  ;;(autoload 'html3-mode "psgml-html" "Mode for HTML editing" t)
  (setq auto-mode-alist (cons '("\\.html?$" . html3-mode) auto-mode-alist)))
 (t
  (autoload 'html-mode "sgml-mode" "Mode for HTML editing." t)
  (autoload 'sgml-mode "sgml-mode" "Mode for SGML editing." t)
  (setq auto-mode-alist (cons '("\\.html?$" . html-mode) auto-mode-alist))))

(autoload 'tex-mode "auc-tex" "Automatic select TeX or LaTeX mode" t)
(autoload 'plain-tex-mode "auc-tex" "Mode for Plain TeX" t)
(autoload 'latex-mode "auc-tex" "Mode for LaTeX" t)
(autoload 'LaTeX-math-mode "tex-math" "Math mode for TeX." t)
(autoload 'outline-minor-mode "outline-m" "Minor Outline Mode." t)
(autoload 'smalltalk-mode "st" "Mode for Smalltalk" t)
(autoload 'perl-mode "perl-mode" "Mode for Perl" t)
(autoload 'pov-mode "pov-mode" "Mode for POV-Ray" t)
(autoload 'mud "mud" "MOO and MUD major mode." t)
(autoload 'csh-mode "csh-mode2" "Mode for CSH scripts." t)
(autoload 'unibasic-mode "unibasic" "Mode for Unibasic source." t)
(autoload 'unibasic-insert-emacs-tag "unibasic" nil t)
(autoload 'proc-mode "proc-mode" "Mode for Pick PROC procedures." t)
(autoload 'proc-insert-emacs-tag "proc-mode" nil t)
(autoload 'ispell-region "ispell" "Check the spelling of region." t)
(autoload 'ispell-word "ispell" "Check the spelling of word in buffer." t)
(autoload 'ispell-buffer "ispell" "Check the spelling of buffer." t)
(autoload 'ispell-message "ispell" "Check spelling of a message." t)
(autoload 'ispell-complete-word "ispell"  "Look up current word in dictionary and try to complete it." t)
(autoload 'ispell-change-dictionary "ispell" "Change ispell dictionary." t)
(autoload 'tailf "tail" "Follow additions to a file." t)
(autoload 'bat-mode "bat-mode" "DOS Batch file editing mode." t)
(if (not running-xemacs)
         (progn
           (autoload 'pidl-mode "idl" 
             "Major mode for the Interactive Data Language." t)
           (setq auto-mode-alist (cons '("\\.pro$" . pidl-mode)
                                         auto-mode-alist ))))
         

(put 'eval-expression 'disabled nil)
(setq auto-mode-alist (append auto-mode-alist
                              '(("\\.c$" . c-mode)
                                ("\\.h$" . c-mode)
                                ("\\.m$" . objc-mode)
                                ("\\.cpp$" . c++-mode)
                                ("\\.cc$" . c++-mode)
                                ("\\.C$" . c++-mode)
                                ("\\.hpp$" . c++-mode)
                                ("\\.java$" . java-mode)
                                ("Makefile$" . makefile-mode)
                                ("\\.txt$" . text-mode)
                                ("\\.el$" . emacs-lisp-mode)
                                ("\\.pov$" . pov-mode)
                                ("\\.st$" . smalltalk-mode)
                                ("\\.ub$" . unibasic-mode)
                                ("\\.stk$" . scheme-mode) ;; STk uses this.
                                ("\\.a$" . c-mode))) )

;; windows font-lock C types.
(if (pat-vboundp 'c-font-lock-extra-types)
    (let ((win-c '("SOCKET" "WPARAM" "LPARAM" "HWND" "HANDLE" "HINSTANCE" 
                   "\\(LP\\|U\\)?\\(BOOL\\|INT\\|SHORT\\|LONG\\)"
                   "\\(LP\\)?\\(DWORD\\|WORD\\|BYTE\\)"
                   "LRESULT" "WINAPI" "HMENU" "MSG" "HRESULT" "VARIANT" 
                   "\\(LP\\)?WNDCLASS\\(EX\\)?" "BSTR" "\\(LP\\)?C?OLESTR"
                   "\\(LP\\)?T?\\(STR\\|CSTR\\|CHAR\\)"
                   "RECT" "POINT" "FARPROC" "CONVINFO" "HCONV" "DISPID"))
          (win-cpp '( "CComBSTR" "CComPtr" "CComVariant")) )
      (setq c-font-lock-extra-types (append c-font-lock-extra-types win-c))
      (setq c++-font-lock-extra-types 
            (append (append c++-font-lock-extra-types win-c) win-cpp)) ))

(defun pat-java-mode-hook ()
  "Set customisations for java mode buffers to stroustrup style indentation."
  (c-set-offset 'substatement-open 0))

(defun pat-c-mode-hook()
  "Customise c-mode"
  (c-set-style "stroustrup")
  (setq indent-tabs-mode nil))

(defun pat-c++-mode-hook ()
  "Customise c++-mode to use the stroustrup C++ file style."
  (c-set-style "stroustrup")
  (setq indent-tabs-mode nil))

(add-hook 'java-mode-hook 'pat-java-mode-hook)
(add-hook 'c-mode-hook    'pat-c-mode-hook)
(add-hook 'c++-mode-hook  'pat-c++-mode-hook)

(defvar cursor-map-2 (make-keymap)
  "Hold a keymap for ESC-[. This does function keys on PC keyboards.")
(fset 'Cursor-Map-2 cursor-map-2)
(define-key esc-map "[" 'Cursor-Map-2)
(define-key esc-map "[A" 'previous-line)     ;; up arrow
(define-key esc-map "[B" 'next-line)         ;; down arrow
(define-key esc-map "[C" 'forward-char)      ;; right arrow
(define-key esc-map "[D" 'backward-char)     ;; left arrow
(define-key esc-map "[H" 'beginning-of-line) ;; home
(define-key esc-map "[Y" 'end-of-line)       ;; end
(define-key esc-map "[5^" 'scroll-down)      ;; page up
(define-key esc-map "[6^" 'scroll-up)        ;; page down
(define-key esc-map "[[A" 'help-for-help)    ;; F1
(define-key global-map [f1] 'help-for-help)
(define-key esc-map "[[B" 'byte-compile-file);; F2
(define-key global-map [f2] 'byte-compile-file)
(define-key esc-map "[[C" 'isearch-forward)  ;; F3
(define-key esc-map "[[D" 'query-replace-regexp) ;; F4
(define-key esc-map "[[E" 'eval-defun)       ;; F5
(define-key esc-map "[[F" 'eval-current-buffer)
(define-key esc-map "[[G" 'buffer-menu)
(define-key esc-map "[[H" 'global-set-key)
(define-key esc-map "[[I" 'save-buffer)
(define-key esc-map "[[J" 'save-buffers-kill-emacs) ;; F10
(define-key function-key-map [f12] 'unibasic-mode) ;; emacs-win32-20.3
;
;; default wintegrate key bindings
(define-key esc-map "[1~" 'beginning-of-line)
(define-key esc-map "[2~" 'set-mark-command)
(define-key esc-map "[3~" 'delete-char)
(define-key esc-map "[4~" 'end-of-line)
(define-key esc-map "[5~" 'scroll-down)
(define-key esc-map "[6~" 'scroll-up)
;
(defvar control-c-keymap (make-keymap) "Hold a keymap for C-c prefix.")
(defun control-c-prefix () control-c-keymap)
(global-set-key "\C-c" (control-c-prefix))
(define-key control-c-keymap "D" 'pat-insert-date)
(define-key control-c-keymap "d"
  (lambda () "" (interactive) 
    (insert (format-time-string "%d %b %Y" (current-time)))))
(define-key control-c-keymap "n" 
  (lambda () "" (interactive) (message "%s" buffer-file-truename)))
(define-key control-c-keymap "e"    'pat-chop-ends)
(define-key control-c-keymap "f"    'pat-w32-select-font)
(define-key control-c-keymap "m"    'LaTeX-math-mode)
;;(define-key control-c-keymap "o"    'outline-minor-mode)
(define-key control-c-keymap "r"    'pat-insert-rot13-string)
(define-key control-c-keymap "u"    'unibasic-mode)
(define-key control-c-keymap "p"    'proc-mode)
(define-key control-c-keymap "\C-u" 'unibasic-insert-emacs-tag)
(define-key control-c-keymap "\C-p" 'proc-insert-emacs-tag)
(define-key control-c-keymap "\C-t" 'pat-insert-tcl-tag)
(define-key control-c-keymap "\C-+" 'pat-insert-c++-tag)
(define-key control-c-keymap "t"    'pat-truncate-lines)
(define-key control-c-keymap "b"    'pat-bar)
(define-key control-c-keymap "w"    'pat-insert-html-header)
(define-key control-c-keymap "&"    'pat-insert-work-copyright-message)
(define-key control-c-keymap "\e&"  'pat-insert-gpl-message)
;;(define-key control-c-keymap [M-&]  'pat-insert-gpl-message)
;
(global-set-key "\e&" 'pat-insert-copyright-message)
(global-set-key "\e$" 'ispell-word)
;;(define-key global-map [M-&] 'pat-insert-copyright-message)
;;(define-key global-map [M-$] 'ispell-word)

;;; Load the auto-save.el package, which lets you put all of your autosave
;;; files in one place, instead of scattering them around the file system.
;;;
(setq auto-save-directory (expand-file-name "~/autosave/"))
;; We load this afterwards because it checks to make sure the
;; auto-save-directory exists (creating it if not) when it's loaded.

(if (condition-case () (require 'auto-save) (error nil))
    (setq auto-save-directory-fallback auto-save-directory
          auto-save-hash-p nil
          efs-auto-save t
          efs-auto-save-remotely nil
          auto-save-interval 2000))     ; 2000 characters between saves

;; func-menu adds a menu for all the functions defined in your source file
;; for a few languages.
(cond
 ((condition-case () (require 'func-menu) (error nil))
  (define-key global-map 'f8 'function-menu)
  (add-hook 'find-file-hooks 'fume-add-menubar-entry)
  (define-key global-map "\C-cl" 'fume-list-functions)
  (define-key global-map "\C-cg" 'fume-prompt-function-goto)
  
  ;; The Hyperbole information manager package uses (shift button2) and
  ;; (shift button3) to provide context-sensitive mouse keys.  If you
  ;; use this next binding, it will conflict with Hyperbole's setup.
  ;; Choose another mouse key if you use Hyperbole.
  (define-key global-map '(shift button3) 'mouse-function-menu)
  
  ;; For descriptions of the following user-customizable variables,
  ;; type C-h v <variable>
  (setq fume-max-items 25
        fume-fn-window-position 3
        fume-auto-position-popup t
        fume-display-in-modeline-p t
        fume-menubar-menu-location "File"
        fume-buffer-name "*Function List*"
        fume-no-prompt-on-valid-default nil))
 ((condition-case () (require 'imenu)     (error nil))
  (if (not (fboundp 'imenu-add-menubar-index)) ;; emacs-19.34 misses this.
      (defun imenu-add-menubar-index () "Insert imenu Index in menubar."
	(interactive) (imenu-add-to-menubar "Index")))
  (add-hook 'unibasic-mode-hook 'imenu-add-menubar-index)
  (add-hook 'c-mode-hook 'imenu-add-menubar-index)
  (add-hook 'emacs-lisp-mode-hook 'imenu-add-menubar-index)))

(make-variable-buffer-local 'outline-prefix-char)
(setq-default outline-prefix-char "\C-l")
(make-variable-buffer-local 'outline-regexp)
(setq-default outline-regexp "[*\l]+")
(make-variable-buffer-local 'outline-level-function)
(setq-default outline-level-function 'outline-level-default)
(eval-after-load "outline" 
  '(condition-case () (require 'foldout) (error nil)))

;; If a terminal mode _insists_ on using C-h for backspace and can't be 
;;changed the use this, and loose C-h for help. :o)
;;
;; We ought to be ok now. I managed to fix wintegrate and as long as we are 
;; using stty dec things should be ok.
(defun pat-fix-keyboard ()
  "Apply a fix for crap terminal emulators.
If the emulator cannot be persuaded to send DEL for the backspace key then
change emacs to use F1 for help and read C-h as delete.
i.e: use with the Windows 95 telnet program."
  (interactive)
  (define-key control-c-keymap "h" 'help-for-help)
  ;;(define-key global-map [f1] 'help-for-help)
  (define-key function-key-map [M-backspace] [?\M-\177])
  (define-key global-map [backspace] 'delete-backward-char))

;; Some settings needed for win32 emacs at home and at CFL
;; don't forget with win95 emacs to set:
;; HKEY_LOCAL_MACHINE\SOFTWARE\GNU\Emacs\SHELL %emacs_dir%/bin/cmdproxy.exe
(cond 
 ((eq window-system 'w32)
  (setq w32-pass-alt-to-system t) 
  (if (not (running-emacs-version-or-newer 20 4))
      (setq process-coding-system-alist
            '(("cmdproxy" . (raw-text-dos . raw-text-dos)))))
  (if (not (string-match "home" (system-name))) ;; for SCFL
      (progn
        (condition-case () (require 'w32-ps-print) (error nil))
        (setq printer-name "//UKNML0682/hp")
        (setq ps-lpr-command "d:\\gstools\\gs5.50\\gswin32c.exe"
              ps-paper-type 'a4
              ps-print-color-p 't
              ps-lpr-switches '("-sDEVICE=mswinpr2 -q -dNOPAUSE -dBATCH")
              ps-printer-name nil)
        
        (set-frame-font 
         ;; "-*-IBSfont-normal-r-*-*-16-120-*-*-c-*-*-ansi-"    ; 12pt
         ;; "-*-Courier New-normal-r-*-*-13-97-*-*-c-*-*-ansi-" ; 10 pt
         ;; "-*-Courier New-normal-r-*-*-11-82-*-*-c-*-*-ansi-" ; 8 pt
         "-*-Courier New-normal-r-*-*-11-82-*-*-c-*-*-ansi-")))
  (defvar grep-null-device null-device)))

(cond
 ((eq window-system 'w32)
  (set-face-foreground 'modeline "dark green")
  (set-face-background 'modeline "light steel blue"))
 ((eq window-system 'x)
  (set-face-foreground 'modeline "chocolate")
  (set-face-background 'modeline "light steel blue")))

(message "Completed loading .emacs version %s"
         (pat-rcs-version _emacs-version))

;; Local variables:
;;   mode: emacs-lisp
;;   line-number-mode: t
;;   column-number-mode: t
;;   indent-tabs-mode: nil
;;   transient-mark-mode: t
;; End: