X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?p=elisp.git;a=blobdiff_plain;f=emacs.el;h=6d4ffe8cad3efe1ec8ebd8abe04975e600e9881a;hp=23ca425186643a733cb21d0caf3aab3d51f0a4e4;hb=41d67536a6418bc1b6259cc3f390b892cb931417;hpb=87b171d58f0b3afc82d8842f2bd01cdc1c367360

diff --git a/emacs.el b/emacs.el
index 23ca425..6d4ffe8 100644
--- a/emacs.el
+++ b/emacs.el
@@ -1,4 +1,4 @@
-;; -*-Emacs-Lisp-*-
+;; -*- mode: Emacs-Lisp; mode: rainbow; -*-
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; This program is free software; you can redistribute it and/or         ;;
@@ -31,6 +31,21 @@
 ;; Xft.antialias: true
 ;; Xft.rgba: rgb
 
+;; (set-default-font "Bitstream vera sans mono-12")
+;; (set-default-font "Liberation Mono-13")
+(set-default-font "Inconsolata 15")
+;; (set-default-font "DejaVu sans mono 11")
+;; (set-default-font "Droid sans mono 13")
+;; (set-default-font "Opensans 10")
+
+(when (fboundp 'horizontal-scroll-bar-mode)
+  (horizontal-scroll-bar-mode -1))
+
+;; This is where I put most of my emacs-related files
+(setq ff/emacs-dir "~/private/emacs")
+(unless (file-exists-p ff/emacs-dir)
+  (mkdir ff/emacs-dir t))
+
 ;; Give the focus to the emacs window if we are under a windowing
 ;; system
 
@@ -42,12 +57,15 @@
 
 (add-to-list 'load-path "~/sources/gpl/elisp")
 (add-to-list 'load-path "~/sources/elisp")
+(add-to-list 'load-path "~/local/elisp")
 
 ;; No, I do not like menus
 (menu-bar-mode -1)
 
 ;; Nor fringes
-(when (functionp 'fringe-mode) (fringe-mode '(0 . 0)))
+;; (when (functionp 'fringe-mode) (fringe-mode '(0 . 0)))
+;; (when (functionp 'fringe-mode) (fringe-mode '(0 . 1)))
+(when (functionp 'fringe-mode) (fringe-mode 10))
 
 ;; And I do not like scrollbar neither
 (when (functionp 'scroll-bar-mode) (scroll-bar-mode -1))
@@ -55,6 +73,10 @@
 ;; Make all "yes or no" prompts be "y or n" instead
 (fset 'yes-or-no-p 'y-or-n-p)
 
+;; The space bar acting as "yes" has been several times really
+;; problematic.
+(define-key query-replace-map (kbd "SPC") nil)
+
 ;; Show the matching parenthesis and do it immediately, we are in a
 ;; hurry
 (setq show-paren-delay 0)
@@ -63,17 +85,22 @@
 ;; use colorization for all modes
 (global-font-lock-mode t)
 
-(setq font-lock-maximum-decoration 2
+(setq font-lock-maximum-decoration 3
       ;;'((latex-mode . 2) (t . 2))
       )
 
 ;; Activate the dynamic completion of buffer names
-(iswitchb-mode 1)
+;; (iswitchb-mode 1)
+;; (load "lcomplete")
 
 ;; Save the minibuffer history
-(setq savehist-file "~/private/emacs/savehist")
+(setq savehist-file (concat ff/emacs-dir "/savehist"))
 (when (functionp 'savehist-mode) (savehist-mode 1))
 
+;; And allow minibuffer recursion
+(setq enable-recursive-minibuffers t)
+(minibuffer-depth-indicate-mode 1)
+
 ;; I do not like tooltips
 (when (functionp 'tooltip-mode) (tooltip-mode nil))
 
@@ -81,7 +108,7 @@
 (icomplete-mode 1)
 
 ;; (setq highlight-current-line-globally t
-      ;; highlight-current-line-ignore-regexp "Faces\\|Colors\\| \\*Mini\\|\\*media\\|INBOX")
+;; highlight-current-line-ignore-regexp "Faces\\|Colors\\| \\*Mini\\|\\*media\\|INBOX")
 
 ;; (highlight-current-line-minor-mode 1)
 ;; (highlight-current-line-set-bg-color "gray75")
@@ -124,8 +151,12 @@ load-warning buffer in case of failure."
 
 ;; make emacs use the clipboard so that copy/paste works for other
 ;; x-programs. I have no clue how all that clipboard thing works.
+
 ;; (setq x-select-enable-clipboard t)
 ;; (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)
+;; (setq x-select-enable-primary t)
+;; (setq x-select-enable-clipboard t)
+;; (global-set-key "\C-y" 'clipboard-yank)
 
 (setq
 
@@ -198,6 +229,9 @@ load-warning buffer in case of failure."
  ;; And I like ascii files
  epa-armor t
 
+ ;; tramp-default-method "ssh"
+ tramp-default-method "scp"
+
  ;; I have no problem with files having their own local variables
  enable-local-eval t
 
@@ -207,6 +241,12 @@ load-warning buffer in case of failure."
  mc-use-default-recipients t
 
  ;; browse-url-new-window-flag t
+
+ ;; I do not like compilation to automatically split the active window
+ ;; vertically, even when the said window is very wide
+ split-height-threshold 0
+ split-width-threshold nil
+
  )
 
 ;; The backups
@@ -222,10 +262,21 @@ load-warning buffer in case of failure."
  backup-by-copying-when-linked t
  )
 
+(setq tramp-backup-directory-alist backup-directory-alist)
+
+(setq user-emacs-directory "~/misc/emacs.d/")
+
+(setq
+ abbrev-file-name (concat user-emacs-directory "abbrev_defs")
+ server-auth-dir (concat user-emacs-directory "server/")
+ custom-theme-directory user-emacs-directory
+ )
+
 ;; Stop this crazy blinking cursor
 (blink-cursor-mode 0)
 
-;; (setq blink-cursor-delay 0.25
+;; (setq blink-cursor-delay 0.05
+;; blink-cursor-blinks 0
 ;; blink-cursor-interval 0.25)
 
 ;; (set-terminal-coding-system 'utf-8)
@@ -253,8 +304,12 @@ load-warning buffer in case of failure."
  ;; This is the default coding system when toggle-input-method is
  ;; invoked (C-\)
  default-input-method "latin-1-prefix"
+
  ;; do not put tabs when indenting
  indent-tabs-mode nil
+ ;; Stop indenting automatically, that's annoying
+ electric-indent-chars nil
+
  ;; And yes, we have a fast display / connection / whatever
  baud-rate 524288
  ;; baud-rate 10
@@ -273,10 +328,14 @@ load-warning buffer in case of failure."
 ;; What modes for what file extentions
 (add-to-list 'auto-mode-alist '("\\.h\\'" . c++-mode))
 
+(add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-mode))
+
+(require 'org-table)
+
 (add-to-list 'auto-mode-alist '("\\.txt\\'" . (lambda()
                                                 (text-mode)
                                                 (orgtbl-mode)
-                                                (auto-fill-mode)
+                                                ;; (auto-fill-mode)
                                                 (flyspell-mode))))
 
 (add-hook 'c++-mode-hook 'flyspell-prog-mode)
@@ -324,15 +383,15 @@ load-warning buffer in case of failure."
    ))
 
 ;; "tool" bar? Are you kidding?
-(when (boundp 'tool-bar-mode) (tool-bar-mode -1))
+(when (fboundp 'tool-bar-mode) (tool-bar-mode -1))
 
 ;; ;; If my own letter icon is here, use it and change its color
 ;; (when (file-exists-p "~/local/share/emacs/letter.xbm")
-  ;; (setq-default display-time-mail-icon
-                ;; (find-image
-                 ;; '((:type xbm
-                          ;; :file "~/local/share/emacs/letter.xbm"
-                          ;; :ascent center)))))
+;; (setq-default display-time-mail-icon
+;; (find-image
+;; '((:type xbm
+;; :file "~/local/share/emacs/letter.xbm"
+;; :ascent center)))))
 
 ;; My funky setting of face colors. Basically, we switch to a sober
 ;; look and darken a bit the colors which need to (because of the
@@ -353,11 +412,13 @@ load-warning buffer in case of failure."
   (ff/configure-faces
    '((italic :underline nil)
      (info-title-2 :foreground "green")
+     (font-lock-comment-delimiter-face :foreground "green")
+     (font-lock-comment-face :foreground "green")
      (cperl-array-face :background "gray90" :foreground "blue" :weight 'bold)
      (cperl-hash-face :background "gray90" :foreground "purple" :weight 'bold)
-     (diff-added-face :foreground "blue" :weight 'bold)
-     (diff-changed-face :foreground "green" :weight 'bold)
-     (diff-removed-face :foreground "red" :weight 'bold)
+     (diff-added :background "gray90" :foreground "green4" :weight 'bold)
+     (diff-removed :background "gray90" :foreground "red2" :weight 'bold)
+     (diff-changed :background "gray90" :foreground "blue" :weight 'bold)
      (diff-file-header-face :background "white" :foreground "black"
                             :weight 'bold)
      (diff-header-face :background "white" :foreground "black")
@@ -369,13 +430,13 @@ load-warning buffer in case of failure."
      (font-lock-string-face :foreground "green")
      (font-lock-variable-name-face :foreground "blue")
      (font-lock-constant-face :foreground "blue")
-     (font-lock-function-name-face :foreground "blue")
      (font-lock-preprocessor-face :foreground "green")
      (font-lock-function-name-face :foreground "cyan")
-     (flyspell-incorrect-face :foreground "red2")
-     (flyspell-duplicate-face :foreground "OrangeRed2")
-     (sh-heredoc :foreground "blue")
-     (sh-heredoc-face :foreground "blue")
+     (flyspell-incorrect :foreground "red2")
+     (flyspell-duplicate :foreground "OrangeRed2")
+     (hl-line :background "white")
+     (sh-heredoc :foreground "black" :background "#fff0f0")
+     (sh-heredoc-face :foreground "black" :background "#fff0f0")
      (font-lock-keyword-face :foreground "blue")
      (highlight :background "darkseagreen3")
      (isearch :background "orange" :foreground "black")
@@ -390,12 +451,16 @@ load-warning buffer in case of failure."
                   :inverse-video nil)
      (mode-line-inactive :background "gray60" :foreground "black" :box nil
                          :inverse-video nil)
-     ;; (tex-verbatim :family nil)
-     (region :background "springgreen2")
+     (region :background "white" :foreground "black")
      (ff/date-info-face :foreground "white" :weight 'bold)
      (ff/mail-alarm-face :foreground "red" :weight 'bold)
+     (selector/selection :background "yellow")
      (gui-button-face :background "green" :foreground "white")
      (enotes/information-face :foreground "cyan")
+
+     (file-name-shadow :foreground "black")
+     (shadow :foreground "black")
+     (warning :foreground "black" :background "red")
      ))
   )
 
@@ -405,19 +470,22 @@ load-warning buffer in case of failure."
 ;; (ff/configure-faces '((default :background "gray80" :foreground "black")))
 
 (when window-system
-  (setq
-   display-time-use-mail-icon t)
+  ;; (setq
+  ;; display-time-use-mail-icon t)
 
   (ff/configure-faces
    '(
-     (escape-glyph :foreground "gray70" :weight 'bold)
+     ;; (escape-glyph :foreground "#c0c0c0" :weight 'bold)
+
+     (escape-glyph :foreground "green3" :weight 'bold)
      (default :background "gray90" :foreground "black")
      (cperl-array-face :background "gray90" :foreground "blue" :weight 'bold)
      (cperl-hash-face :background "gray90" :foreground "purple" :weight 'bold)
      (message-cited-text :foreground "red4")
+     (diff-mode :background "gray90" :weight 'bold)
      (diff-added :background "gray90" :foreground "green4" :weight 'bold)
      (diff-removed :background "gray90" :foreground "red2" :weight 'bold)
-     (diff-changed :background "gray90" :foreground "blue")
+     (diff-changed :background "gray90" :foreground "blue" :weight 'bold)
      (diff-file-header :background "white" :foreground "black"
                        :weight 'bold)
      (diff-header :background "white" :foreground "black")
@@ -425,35 +493,39 @@ load-warning buffer in case of failure."
      (font-lock-builtin-face :foreground "deeppink3")
      (font-lock-string-face :foreground "dark olive green")
      (font-lock-variable-name-face :foreground "sienna")
-     (font-lock-function-name-face :foreground "blue4" :weight 'bold)
-     ;; (font-lock-comment-face :foreground "")
-     (flyspell-incorrect-face :foreground "red2")
-     (flyspell-duplicate-face :foreground "OrangeRed2")
+     ;; (font-lock-function-name-face :foreground "blue" :weight 'bold)
+     (font-lock-function-name-face :foreground "blue")
+     ;; (font-lock-comment-delimiter-face :foreground "dark violet")
+     ;; (font-lock-comment-face :foreground "dark violet")
+     (flyspell-incorrect :background "#ff0000" :foreground "black")
+     (flyspell-duplicate :background "#ff9000" :foreground "black")
+     (hl-line :background "white")
+     (sh-heredoc :foreground "black" :background "#fff0f0")
+     (sh-heredoc-face :foreground "black" :background "#fff0f0")
      (header-line :background "gray65")
-     (sh-heredoc :foreground "darkorange3")
-     (sh-heredoc-face :foreground "darkorange3")
      (highlight :background "turquoise")
      (message-cited-text-face :foreground "firebrick")
      (isearch :background "yellow" :foreground "black")
      (isearch-lazy-highlight-face' :background "yellow3" :foreground "black")
-     (region :background "light sky blue" :foreground "black")
+     (region :background "#b8b8e0" :foreground "black")
      ;; (region :background "plum" :foreground "black")
      (show-paren-match-face :background "gold" :foreground "black")
      (show-paren-mismatch-face :background "red" :foreground "black")
      (trailing-whitespace :background "gray65")
      (cursor :inverse-video t)
      (enotes/list-title-face :foreground "blue" :weight 'bold)
-     (mode-line :background "#9090f0" :foreground "black" :box nil
+     (mode-line :background "#b0b0ff" :foreground "black" :box nil
                 :inverse-video nil)
      (header-line :background "cornflowerblue" :foreground "black" :box nil
                   :inverse-video nil)
-     (mode-line-inactive :background "#606080" :foreground "black" :box nil
+     (mode-line-inactive :background "gray80" :foreground "black" :box nil
                          :inverse-video nil)
      ;; (fringe :background "black" :foreground "gray90")
-     (fringe :background "gray65")
+     (fringe :background "gray80")
      (ff/date-info-face :foreground "white" :weight 'bold)
      (ff/mail-alarm-face :foreground "white" :background "red2")
      ;; (alarm-vc-face :foreground "black" :background "yellow" :weight 'normal)
+     (gui-button-face :background "green" :foreground "black")
      ))
   )
 
@@ -465,6 +537,19 @@ load-warning buffer in case of failure."
                 :inverse-video nil))
    ))
 
+;; Why should I have to do this?
+(add-hook 'sh-mode-hook
+          (lambda ()
+            (set-face-attribute 'sh-heredoc nil
+                                :foreground "#604000"
+                                :background "white"
+                                :italic t)
+            (set-face-attribute 'sh-heredoc-face nil
+                                :foreground "#604000"
+                                :background "white"
+                                :italic t)
+            ))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Move the window on the buffer without moving the cursor
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -499,6 +584,16 @@ load-warning buffer in case of failure."
 
 (define-key global-map [(meta up)] 'ff/scroll-down)
 (define-key global-map [(meta down)] 'ff/scroll-up)
+
+(define-key global-map [(meta shift up)]
+  (lambda () (interactive) (condition-case nil (scroll-down 10) (error nil))))
+
+(define-key global-map [(meta shift down)]
+  (lambda () (interactive) (condition-case nil (scroll-up 10) (error nil))))
+
+;; (define-key global-map [(meta shift up)] (lambda () (interactive) (ff/scroll-down 10)))
+;; (define-key global-map [(meta shift down)] 'ff/scroll-up)
+
 (define-key global-map [(meta p)] 'ff/scroll-down)
 (define-key global-map [(meta n)] 'ff/scroll-up)
 (define-key global-map [(meta right)] 'ff/scroll-left)
@@ -563,31 +658,6 @@ load-warning buffer in case of failure."
 ;; Counting various entities in text
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defun ff/count-char ()
-  "Prints the number of characters between the first previous \"--\"
-and the firt next \"--\"."
-  (interactive)
-  (let ((from (save-excursion (re-search-backward "^--$" nil t)))
-        (to (save-excursion (re-search-forward "^--$" nil t))))
-    (if (and to from) (message "%d character(s)" (- to from 6))
-      (error "Can not find the -- delimiters"))))
-
-(defun ff/count-words ()
-  "Print number of words between the first previous \"--\" and the
-firt next \"--\"."
-  (interactive)
-  (let ((from (save-excursion (re-search-backward "^--$" nil t)))
-        (to (save-excursion (re-search-forward "^--$" nil t))))
-    (if (and to from)
-        (save-excursion
-          (goto-char from)
-          (let ((count 0))
-            (while (< (point) to)
-              (re-search-forward "\\w+\\W+")
-              (setq count (1+ count)))
-            (message "%d word(s)" count)))
-      (error "Can not find the -- delimiters"))))
-
 (defun ff/word-occurences ()
   "Display in a new buffer the list of words sorted by number of
 occurrences "
@@ -645,15 +715,15 @@ occurrences "
 ;; Printing
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(require 'ps-print)
+(load "ps-print")
 
 (setq ps-print-color-p nil
-      ;; ps-paper-type 'letter
-      ps-paper-type 'a4
-      ps-top-margin (* 1.75 56.692)
-      ps-left-margin 56.692
-      ps-bottom-margin 56.692
-      ps-right-margin 56.692
+      ps-paper-type 'letter
+      ;; ps-paper-type 'a4
+      ;; ps-top-margin (* 1.75 56.692)
+      ;; ps-left-margin 56.692
+      ;; ps-bottom-margin 56.692
+      ;; ps-right-margin 56.692
 
       ;; Simple header. Remove that silly frame shadow.
       ps-print-header nil
@@ -661,7 +731,8 @@ occurrences "
       ps-header-line-pad 0.3
       ps-header-font-family 'Courier
       ps-header-title-font-size '(8.5 . 10)
-      ps-header-font-size '(6 . 7)
+      ;; ps-header-font-size '(6 . 7)
+      ps-header-font-size '(10 . 12)
       ps-font-size '(7 . 8)
       )
 
@@ -672,6 +743,26 @@ occurrences "
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;; http://blog.tuxicity.se/elisp/emacs/2010/03/26/rename-file-and-buffer-in-emacs.htm
+
+(defun rename-file-and-buffer ()
+  "Renames current buffer and file it is visiting."
+  (interactive)
+  (let ((name (buffer-name))
+        (filename (buffer-file-name)))
+    (if (not (and filename (file-exists-p filename)))
+        (message "Buffer '%s' is not visiting a file!" name)
+      (let ((new-name (read-file-name "New name: " filename)))
+        (cond ((get-buffer new-name)
+               (message "A buffer named '%s' already exists!" new-name))
+              (t
+               (rename-file name new-name 1)
+               (rename-buffer new-name)
+               (set-visited-file-name new-name)
+               (set-buffer-modified-p nil)))))))
+
+(global-set-key (kbd "C-c r") 'rename-file-and-buffer)
+
 (defun ff/non-existing-filename (dir prefix suffix)
   "Returns a filename of the form DIR/PREFIX[.n].SUFFIX whose file does
 not exist"
@@ -727,147 +818,135 @@ printer."
 ;; Dealing with the laptop battery
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defcustom ff/battery-file "/proc/acpi/battery/BAT0"
+(defcustom ff/battery-dirs '("/sys/class/power_supply/BAT0"
+                             "/sys/class/power_supply/BAT1")
   "*Where to gather the battery information")
 
-(defcustom ff/thermal-file "/proc/acpi/thermal_zone/THM1/"
+(defcustom ff/temperature-files '("/sys/class/thermal/thermal_zone0/temp"
+                                  "/sys/class/thermal/thermal_zone1/temp")
   "*Where to gather the thermal information")
 
-(defun ff/battery-info (path)
-
-  (let ((state nil)
-        (full nil)
-        (charge nil)
-        (rate nil))
-
-    (with-temp-buffer
-      (insert-file-contents-literally (concat path "/state"))
-      (while (re-search-forward "^\\([a-z ]*\\): *\\(.*\\)$" nil t)
-        (let ((field (match-string 1))
-              (value (match-string 2)))
-
-          (cond ((string= field "charging state")
-                 (cond ((string= value "charged") (setq state 'charged))
-                       ((string= value "charging") (setq state 'charging))
-                       ((string= value "discharging")(setq state 'discharging))
-                       (t (setq state 'unknown))))
-
-                ((string= field "remaining capacity")
-                 (setq charge (string-to-number value)))
-
-                ((string= field "present rate")
-                 (setq rate (string-to-number value)))))))
-
-    (with-temp-buffer
-      (insert-file-contents-literally (concat path "/info"))
-      (while (re-search-forward "^\\([a-z ]*\\): *\\(.*\\)$" nil t)
-        (let ((field (match-string 1))
-              (value (match-string 2)))
-
-          (cond ((string= field "last full capacity")
-                 (setq full (string-to-number value)))))))
-
-    (list state full charge rate)))
-
-(defun ff/thermal-info (path)
-  (let ((temperature nil))
-    (with-temp-buffer
-      (insert-file-contents-literally (concat path "/temperature"))
-      (while (re-search-forward "^\\([a-z ]*\\): *\\(.*\\)$" nil t)
-        (let ((field (match-string 1))
-              (value (match-string 2)))
-
-          (cond ((string= field "temperature")
-                 (setq temperature (string-to-number value)))))))
+(defun ff/file-first-line (file)
+  (with-temp-buffer
+    (insert-file-contents-literally file)
+    (buffer-substring (point-at-bol) (point-at-eol))))
+
+(defun ff/battery-discharging (l)
+  (and l (or (string= (ff/file-first-line (concat (car l) "/status")) "Discharging")
+             (ff/battery-discharging (cdr l)))))
+
+;; If there is one "Discharging" among the states of all the
+;; batteries, the global state is 'discharging. Otherwise, if there is
+;; a "Charging", the state is 'charging. If none is true, it is
+;; 'unknown
+(defun ff/battery-state (l)
+  (if l
+      (let ((u (ff/file-first-line (concat (car l) "/status"))))
+        (if (string= u "Discharging") 'discharging
+          (let ((s (ff/battery-state (cdr l))))
+            (if (eq s 'discharging) 'discharging
+              (if (or (eq s 'charging) (string= u "Charging"))
+                  'charging
+                'unknown))
+            )
+          )
+        )
+    'unknown))
 
-    (list temperature)))
+(defun ff/sum-values-from-files (list-files prefix)
+  (apply '+
+         (mapcar
+          (lambda (f)
+            (condition-case nil
+                (string-to-number (ff/file-first-line (format "%s/%s" f prefix)))
+              (error 0))
+            )
+          list-files)))
 
-(defun ff/laptop-info-string () (interactive)
+(defun ff/battery-percent ()
   (condition-case nil
-      (let ((info (ff/battery-info ff/battery-file))
-            (temperature (car (ff/thermal-info ff/thermal-file))))
-
-        (concat
+      (/ (* 100 (ff/sum-values-from-files ff/battery-dirs "energy_now"))
+         (ff/sum-values-from-files ff/battery-dirs "energy_full"))
+    (error -1))
+  )
 
-         ;; The temperature
+(defun ff/temp-and-battery-info-string () (interactive)
+       (condition-case nil
+           (concat
 
-         (if (> temperature 50)
-             (concat
-              (let ((s (format "%dC" temperature)))
-                (if (> temperature 65) (propertize s 'face
-                                                   'font-lock-warning-face)
-                  s))
-              "/"
+            ;; The temperature
+
+            (let ((temp (/
+                         (apply 'max (mapcar
+                                      (lambda (f) (string-to-number (ff/file-first-line f)))
+                                      ff/temperature-files))
+                         1000)))
+
+              (if (> temp 50)
+                  (let ((s (format "%dC " temp)))
+                    (if (> temp 70)
+                        (propertize s 'face 'font-lock-warning-face)
+                      s)
+                    )
+                )
               )
-           )
-
-         ;; The battery
-
-         (cond
 
-          ((eq (nth 0 info) 'charged) "L")
+            ;; The battery
 
-          ((eq (nth 0 info) 'discharging)
-           (let* ((time (/ (* (nth 2 info) 60) (nth 3 info)))
-                  (s (format "B%d:%02d" (/ time 60) (mod time 60))))
-             (if (< time 15)
-                 ;; Les than 15 minutes, let's write the remaining
-                 ;; time in red
-                 (propertize s 'face 'font-lock-warning-face)
-               s)))
+            (pcase (ff/battery-state ff/battery-dirs)
+              (`charging (format "c%d%%" (ff/battery-percent)))
+              (`discharging (format "d%d%%" (ff/battery-percent)))
+              (`unknown "f")
+              (_ "?"))
 
-          ((eq (nth 0 info) 'charging)
-           (format "L%2d%%" (/ (* 100 (nth 2 info)) (nth 1 info))))
+            )
 
-          (t (format "???"))
-
-          )))
-
-    (error nil)))
+         (error nil))
+       )
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defun ff/system-info () (interactive)
 
-  (let ((buf (get-buffer-create "*system info*"))
-        (map (make-sparse-keymap)))
-
-    (define-key map "q" 'kill-this-buffer)
-    (display-buffer buf)
-    (set-buffer buf)
-    (setq show-trailing-whitespace nil)
-    (erase-buffer)
-
-    (let ((highlight nil))
-
-      (mapc (lambda (x)
-              (insert
-               (if (setq highlight (not highlight))
-                   (propertize
-                    (with-temp-buffer (apply 'call-process x)
-                                      (buffer-string))
-                    'face 'highlight)
-                 (with-temp-buffer (apply 'call-process x)
-                                   (buffer-string))
-                 ))
-              )
-
-            '(
-              ("hostname" nil t nil "-v")
-              ("acpi" nil t)
-              ("df" nil t nil "-h")
-              ;; ("mount" nil t)
-              ("ifconfig" nil t)
-              ("ssh-add" nil t nil "-l")
-              )))
-
-    (goto-char (point-min))
-    (while (re-search-forward "^$" nil t) (backward-delete-char 1))
-
-    (fit-window-to-buffer (get-buffer-window buf))
-    (use-local-map map)
-    (set-buffer-modified-p nil)
-    ))
+       (let ((buf (get-buffer-create "*system info*"))
+             (map (make-sparse-keymap)))
+
+         (define-key map "q" 'kill-this-buffer)
+         (display-buffer buf)
+         (set-buffer buf)
+         (setq show-trailing-whitespace nil)
+         (erase-buffer)
+
+         (let ((highlight nil))
+
+           (mapc (lambda (x)
+                   (insert
+                    (if (setq highlight (not highlight))
+                        (propertize
+                         (with-temp-buffer (apply 'call-process x)
+                                           (buffer-string))
+                         'face '(:background "#c0c0ff"))
+                      (with-temp-buffer (apply 'call-process x)
+                                        (buffer-string))
+                      ))
+                   )
+
+                 '(
+                   ("hostname" nil t nil "-f")
+                   ("acpi" nil t)
+                   ("df" nil t nil "-h")
+                   ;; ("mount" nil t)
+                   ("ifconfig" nil t)
+                   ("ssh-add" nil t nil "-l")
+                   )))
+
+         (goto-char (point-min))
+         (while (re-search-forward "^$" nil t) (backward-delete-char 1))
+
+         (fit-window-to-buffer (get-buffer-window buf))
+         (use-local-map map)
+         (set-buffer-modified-p nil)
+         ))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Make a sound when there is new mail
@@ -896,6 +975,7 @@ printer."
  display-time-interval 15 ;; Check every 15s
 
  display-time-string-forms `(
+
                              ;; (if mail
                              ;;     (concat " "
                              ;;             (propertize " mail "
@@ -903,6 +983,9 @@ printer."
                              ;;             " ")
                              ;;   )
 
+                             ,(if (ff/temp-and-battery-info-string)
+                                  '(concat (ff/temp-and-battery-info-string) " "))
+
                              (propertize (concat 24-hours ":" minutes
                                                  " "
                                                  dayname " "
@@ -912,13 +995,10 @@ printer."
 
                              load
 
-                             ,(if (ff/laptop-info-string)
-                                  '(concat " /" (ff/laptop-info-string) "/"))
-
                              )
 
- ;;  display-time-format "%b %a %e %H:%M"
- ;;  display-time-mail-face nil
+ ;; display-time-format "%b %a %e %H:%M"
+ ;; display-time-mail-face nil
  )
 
 ;; Show the time, mail and stuff
@@ -948,8 +1028,13 @@ printer."
       (setq list (cdr list)))
     (switch-to-buffer found)))
 
-(define-key global-map [?\C-x right] 'ff/next-buffer)
-(define-key global-map [?\C-x left] 'ff/prev-buffer)
+;; (define-key global-map [?\C-x right] 'ff/next-buffer)
+;; (define-key global-map [?\C-x left] 'ff/prev-buffer)
+;; (define-key global-map [?\M-\]] 'ff/next-buffer)
+;; (define-key global-map [?\M-\[] 'ff/prev-buffer)
+
+(define-key global-map [(meta right)] 'ff/next-buffer)
+(define-key global-map [(meta left)] 'ff/prev-buffer)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; There is actually a decent terminal emulator in emacs!
@@ -957,11 +1042,16 @@ printer."
 
 (load "term")
 
+(defun ff/kill-associated-buffer (process str) (interactive)
+       (let ((buffer (process-buffer process)))
+         (kill-buffer buffer))
+       (message "Process finished (%s)" (replace-regexp-in-string "\n$" "" str)))
+
 (defun ff/kill-associated-buffer-and-delete-windows (process str) (interactive)
-  (let ((buffer (process-buffer process)))
-    (delete-windows-on buffer)
-    (kill-buffer buffer))
-  (message "Process finished (%s)" (replace-regexp-in-string "\n$" "" str)))
+       (let ((buffer (process-buffer process)))
+         (delete-windows-on buffer)
+         (kill-buffer buffer))
+       (message "Process finished (%s)" (replace-regexp-in-string "\n$" "" str)))
 
 (defun ff/shell-new-buffer (buffername program &rest param)
   "Start a terminal-emulator in a new buffer with the shell PROGRAM,
@@ -1003,9 +1093,12 @@ In line mode: M-p previous line, M-n next line.")
     (let ((process (get-buffer-process (current-buffer))))
       (process-kill-without-query process)
       (set-process-sentinel process
-                            'ff/kill-associated-buffer-and-delete-windows))
+                            ;; 'ff/kill-associated-buffer-and-delete-windows
+                            'ff/kill-associated-buffer
+                            ))
 
-    (switch-to-buffer-other-window (concat "*" bn "*"))
+    ;; (switch-to-buffer-other-window (concat "*" bn "*"))
+    (switch-to-buffer (concat "*" bn "*"))
     ))
 
 (defcustom ff/default-bash-commands '("ssh")
@@ -1034,7 +1127,7 @@ of commands in `ff/default-bash-commands' is used for auto-completion"
  vc-follow-symlinks t
  )
 
-(when (require 'vc-git nil t)
+(when (load "vc-git" nil t)
   (add-to-list 'vc-handled-backends 'GIT))
 
 ;; alarm-vc.el is one of my own scripts, check my web page
@@ -1052,21 +1145,24 @@ of commands in `ff/default-bash-commands' is used for auto-completion"
 
 ;; Please consider the security-related consequences of using it
 
-(defun ff/make-shell-scripts-executable (&optional filename)
-  (setq filename (or filename (buffer-name)))
-  (when (and (string-match "\\.sh$\\|\\.pl$\\|\\.rb" filename)
-             (not (file-executable-p filename))
-             )
-    (set-file-modes filename 493)
-    (message "Made %s executable" filename)))
+;; (defun ff/make-shell-scripts-executable (&optional filename)
+;; (setq filename (or filename (buffer-name)))
+;; (when (and (string-match "\\.sh$\\|\\.pl$\\|\\.rb" filename)
+;; (not (file-executable-p filename))
+;; )
+;; (set-file-modes filename 493)
+;; (message "Made %s executable" filename)))
 
-(add-hook 'after-save-hook 'ff/make-shell-scripts-executable)
+;; (add-hook 'after-save-hook 'ff/make-shell-scripts-executable)
+
+(add-hook 'after-save-hook
+          'executable-make-buffer-file-executable-if-script-p)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Cool stuff to navigate in emacs-lisp sources
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(require 'find-func)
+(load "find-func")
 
 (defun ff/goto-function-definition (&optional goback)
   "Go directly to the definition of the function at point. With
@@ -1103,6 +1199,8 @@ goback argument, go back where we were."
 ;; Failsafe version if we can't load bbdb
 (defun ff/explicit-name (email) email)
 
+(load "vc-git")
+
 (when (ff/load-or-alert "bbdb")
 
   (setq
@@ -1128,7 +1226,7 @@ goback argument, go back where we were."
     "The face to display known mail identities.")
 
   (defface ff/unknown-address-face
-    '((t (:foreground "red3")))
+    '((t (:foreground "gray50")))
     "The face to display unknown mail identities.")
 
   (defun ff/explicit-name (email)
@@ -1157,7 +1255,7 @@ ff/known-address-face is used."
                                             (bbdb-record-raw-notes record)))
                                 'ff/known-address-face))
               (error
-               (propertize (or (and data (concat "<" email ">"))
+               (propertize (or (and data (concat "<" net ">"))
                                "*undefined*")
                            'face 'ff/unknown-address-face)
                ))
@@ -1166,15 +1264,11 @@ ff/known-address-face is used."
     )
 
   (ff/configure-faces '((ff/robot-address-face :foreground "green4")
-                        (ff/important-address-face :foreground "blue2"
-                                                   ;; :underline t
-                                                   ;; :background "white"
-                                                   ;; :foreground "green4"
+                        (ff/personal-address-face :foreground "dark magenta" :weight 'bold)
+                        (ff/important-address-face :foreground "red3"
                                                    :weight 'bold
-                                                   ;; :slant 'italic
                                                    )))
 
-
   )
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1189,33 +1283,37 @@ ff/known-address-face is used."
   )
 
 (defface ff/secure-date
-  '((t (:background "gold" :weight bold)))
+  '((t (:background "white" :weight bold)))
   "The face to display the dates in the modeline.")
 
 (defun ff/secure-note-add () (interactive)
-  (find-file "~/private/secure-notes.gpg")
 
-  ;; Adds a new entry (i.e. date and a bunch of empty lines)
+       (unless
+           (let ((b (find-buffer-visiting ff/secure-note-file)))
+             (and b (switch-to-buffer b)))
+         (find-file ff/secure-note-file)
+         ;; Adds a new entry (i.e. date and a bunch of empty lines)
+         (goto-char (point-min))
+         (insert "-- "
+                 (format-time-string "%Y %b %d %H:%M:%S" (current-time))
+                 " --\n\n")
+         (previous-line 1)
+         )
 
-  (goto-char (point-min))
-  (insert "-- "
-          (format-time-string "%Y %b %d %H:%M:%S" (current-time))
-          " ------------------------------------------------\n\n")
-  (previous-line 1)
+       ;; Colorizes the dates
 
-  ;; Colorizes the dates
+       (save-excursion
+         (goto-char (point-min))
+         (while (re-search-forward
+                 "^-- [0-9]+ [a-z]+ [0-9]+ [0-9]+:[0-9]+:[0-9]+ -+$"
+                 nil t)
+           (add-text-properties
+            (match-beginning 0) (1+ (match-end 0))
+            '(face ff/secure-date rear-nonsticky t))))
 
-  (save-excursion
-    (goto-char (point-min))
-    (while (re-search-forward
-            "^-+ [0-9]+ [a-z]+ [0-9]+ [0-9]+:[0-9]+:[0-9]+.+$"
-            nil t)
-      (add-text-properties
-       (match-beginning 0) (match-end 0) '(face ff/secure-date))))
-
-  (set-buffer-modified-p nil)
-  (setq buffer-undo-list nil)
-  )
+       (set-buffer-modified-p nil)
+       (setq buffer-undo-list nil)
+       )
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Spelling
@@ -1273,12 +1371,15 @@ universal argument starts xfig even if the .fig does not exist"
                   (or (re-search-forward "{\\([^{}]*.\\)eps}" (point-at-eol) t)
                       (re-search-forward "{\\([^{}]*.\\)pdf}" (point-at-eol) t)
                       (re-search-forward "{\\([^{}]*.\\)pdf_t}" (point-at-eol) t)
+                      (re-search-forward "{\\([^{}]*.\\)png}" (point-at-eol) t)
+                      (re-search-forward "{\\([^{}]*.\\)jpg}" (point-at-eol) t)
                       )))
            (and (<= (match-beginning 1) (point))
                 (>= (match-end 1) (- (point) 2))))
 
       (ff/run-eps-edition (match-string-no-properties 1)
                           '(("fig" . "xfig")
+                            ("jpg" . "gimp" )
                             ("png" . "gimp") ("pgm" . "gimp") ("ppm" . "gimp")
                             ("jpg" . "xv"))
                           universal)
@@ -1367,18 +1468,22 @@ universal argument starts xfig even if the .fig does not exist"
 (when (ff/load-or-alert "lookup-dict" t)
   (define-key global-map [(control \?)] 'lookup-dict))
 
+;; (defun ff/generate-password () (interactive)
+;; (let ((c "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"))
+;; (nth (random (length c)) c))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Automatization of things I do often
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defun ff/snip () (interactive)
-  (let ((start (condition-case nil (region-beginning) (error (point))))
-        (end (condition-case nil (region-end) (error (point)))))
-    (goto-char end)
-    (insert "---------------------------- snip snip -------------------------------\n")
-    (goto-char start)
-    (insert "---------------------------- snip snip -------------------------------\n")
-    ))
+       (let ((start (condition-case nil (region-beginning) (error (point))))
+             (end (condition-case nil (region-end) (error (point)))))
+         (goto-char end)
+         (insert "----------------------------- snip snip -----------------------------\n")
+         (goto-char start)
+         (insert "----------------------------- snip snip -----------------------------\n")
+         ))
 
 (defun ff/start-latex ()
   "Adds all that stuff to start a new LaTeX document."
@@ -1386,27 +1491,41 @@ universal argument starts xfig even if the .fig does not exist"
   (goto-char (point-min))
   (insert "%% -*- mode: latex; mode: reftex; mode: flyspell; coding: utf-8; tex-command: \"pdflatex.sh\" -*-
 
-\\documentclass[12pt]{article}
-\\usepackage{epsfig}
-\\usepackage{a4}
+\\documentclass[12pt,a4paper,twoside]{article}
+\\usepackage[a4paper,top=2.5cm,bottom=2cm,left=2.5cm,right=2.5cm]{geometry}
+\\usepackage[utf8]{inputenc}
 \\usepackage{amsmath}
 \\usepackage{amssymb}
-\\usepackage[utf8]{inputenc}
-%% \\usepackage{eurosym}
-%% \\usepackage{hyperref}
-%% \\usepackage{harvard}
-
-%% Sans serif fonts
-%% \\usepackage[T1]{fontenc}
-%% \\usepackage[scaled]{helvet}
-%% \\usepackage[cm]{sfmath}
-%% \\renewcommand{\\ttdefault}{pcr}
-%% \\renewcommand*\\familydefault{\\sfdefault}
+\\usepackage[pdftex]{graphicx}
+\\usepackage{microtype}
+\\usepackage[colorlinks=true,linkcolor=blue,urlcolor=blue,citecolor=blue]{hyperref}
 
 \\setlength{\\parindent}{0cm}
 \\setlength{\\parskip}{12pt}
-
-%% \\renewcommand{\\baselinestretch}{1.3}
+\\renewcommand{\\baselinestretch}{1.3}
+
+\\def\\argmax{\\operatornamewithlimits{argmax}}
+\\def\\argmin{\\operatornamewithlimits{argmin}}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Open sans font
+%%\\usepackage[default]{opensans}
+%%\\usepackage{cmbright}
+%%\\renewcommand{\\familydefault}{fos}
+%%\\renewcommand{\\seriesdefault}{l}
+%%\\renewcommand{\\bfdefault}{sb}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% The \\todo command
+\\newcounter{nbdrafts}
+\\setcounter{nbdrafts}{0}
+\\makeatletter
+\\newcommand{\\checknbdrafts}{
+\\ifnum \\thenbdrafts > 0
+\\@latex@warning@no@line{*WARNING* The document contains \\thenbdrafts \\space draft note(s)}
+\\fi}
+\\newcommand{\\todo}[1]{\\addtocounter{nbdrafts}{1}{\\color{red} #1}}
+\\makeatother
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \\begin{document}
 
@@ -1424,25 +1543,12 @@ universal argument starts xfig even if the .fig does not exist"
 (defun ff/add-copyrights ()
   "Adds two lines for the (C) at the beginning of current buffer."
   (interactive)
-  (let ((comment-style 'plain)
-        (gpl
-         (concat
-
-          "\nSTART_IP_HEADER\n"
-
-          (when (boundp 'user-full-name)
-            (concat "\nWritten by " user-full-name "\n"))
 
-          (when (boundp 'user-mail-address)
-            (concat "Contact <" user-mail-address "> for comments & bug reports\n"))
-
-          "\nEND_IP_HEADER\n"
-
-          )))
+  (let ((comment-style 'plain))
 
     (goto-char (point-min))
 
-    ;; If this is a script, put the gpl after the first line
+    ;; If this is a script, put the copyrights after the first line
 
     (when (re-search-forward "^#!" nil t)
       (beginning-of-line)
@@ -1450,13 +1556,34 @@ universal argument starts xfig even if the .fig does not exist"
 
     (let ((start (point))
           (comment-style 'box))
-      (insert gpl)
+      (insert
+       (concat
+
+        "\nSTART_IP_HEADER\n"
+
+        (when (boundp 'user-full-name)
+          (concat "\nWritten by " user-full-name "\n"))
+
+        (when (boundp 'user-mail-address)
+          (concat "Contact <" user-mail-address "> for comments & bug reports\n"))
+
+        "\nEND_IP_HEADER\n"
+        ))
+
       (comment-region start (point)))
 
     ))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defun ff/remove-ip-header () (interactive)
+       (save-excursion
+         (goto-char (point-min))
+         (when (and (re-search-forward "START_IP_HEADER" nil t)
+                    (re-search-forward "END_IP_HEADER" nil t))
+           (message "yep"))
+         ))
+
 (defun ff/add-gpl ()
   "Adds the GPL statements at the beginning of current buffer."
   (interactive)
@@ -1517,6 +1644,24 @@ END_IP_HEADER
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defun ff/start-c ()
+  "Adds the header to start a C program."
+  (interactive)
+  ;;   (beginning-of-buffer)
+  (insert
+   "
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+  exit(EXIT_SUCCESS);
+}
+")
+  (previous-line 2)
+  )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defun ff/start-c++ ()
   "Adds the header to start a C++ program."
   (interactive)
@@ -1545,7 +1690,7 @@ int main(int argc, char **argv) {
   (interactive)
   (let ((flag-name (replace-regexp-in-string
                     "[\. \(\)]" "_"
-                    (upcase (file-name-nondirectory (buffer-name))))))
+                    (upcase (file-name-nondirectory (buffer-file-name))))))
     (goto-char (point-max))
     (insert "\n#endif\n")
     (goto-char (point-min))
@@ -1568,6 +1713,11 @@ int main(int argc, char **argv) {
 <head>
 <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />
 <title></title>
+<style type=\"text/css\">
+p {
+ color:#009900;
+}
+</style>
 </head>
 
 <body>
@@ -1587,8 +1737,8 @@ int main(int argc, char **argv) {
 
 (defun ff/cout-var (arg)
   "Invoked on a line with a list of variables names,
-it inserts a line which displays their values in cout
-(or cerr if the function is invoked with a universal arg)"
+it inserts a line which displays their values in cout, or cerr if
+the function is invoked with a universal arg"
   (interactive "P")
   (let ((line (if arg "cerr" "cout")))
     (goto-char (point-at-bol))
@@ -1632,12 +1782,16 @@ and refilling all the paragraphs."
 "))
   )
 
-(add-hook 'latex-mode-hook (lambda ()
-                             (define-key latex-mode-map
-                               [(meta S)] 'ff/start-slide)
-                             (define-key latex-mode-map
-                               [(control c) (control a)] 'align-current)
-                             ))
+(add-hook
+ 'latex-mode-hook
+ (lambda ()
+   (define-key latex-mode-map [(meta S)] 'ff/start-slide)
+   (define-key latex-mode-map [(control c) (control a)] 'align-current)
+   (define-key latex-mode-map [(control end)] 'tex-close-latex-block)
+   (define-key latex-mode-map [(control tab)] 'ispell-complete-word)
+   (copy-face 'default 'tex-verbatim)
+   ;; (ff/configure-faces '((tex-verbatim :background "gray95")))
+   ))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -1660,26 +1814,26 @@ and refilling all the paragraphs."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defun ff/code-to-html () (interactive)
-  (save-restriction
-    (narrow-to-region (region-beginning) (region-end))
-    (replace-string "\"" "&quot;" nil (point-min) (point-max))
-    (replace-string " " "&nbsp;" nil (point-min) (point-max))
-    (replace-string ">" "&gt;" nil (point-min) (point-max))
-    (replace-string "<" "&lt;" nil (point-min) (point-max))
-    (replace-string "\e" "^[" nil (point-min) (point-max))
-    (replace-string "" "^?" nil (point-min) (point-max))
-    (replace-string "" "^_" nil (point-min) (point-max))
-    (replace-regexp "$" "<br />" nil (point-min) (point-max))
-    )
-  )
+       (save-restriction
+         (narrow-to-region (region-beginning) (region-end))
+         (replace-string "\"" "&quot;" nil (point-min) (point-max))
+         (replace-string " " "&nbsp;" nil (point-min) (point-max))
+         (replace-string ">" "&gt;" nil (point-min) (point-max))
+         (replace-string "<" "&lt;" nil (point-min) (point-max))
+         (replace-string "\e" "^[" nil (point-min) (point-max))
+         (replace-string "" "^?" nil (point-min) (point-max))
+         (replace-string "" "^_" nil (point-min) (point-max))
+         (replace-regexp "$" "<br />" nil (point-min) (point-max))
+         )
+       )
 
 (defun ff/downcase-html-tags () (interactive)
-  (save-excursion
-    (beginning-of-buffer)
-    (while (re-search-forward "<\\([^>]+\\)>" nil t)
-      (downcase-region (match-beginning 1) (match-end 1)))
-    )
-  )
+       (save-excursion
+         (beginning-of-buffer)
+         (while (re-search-forward "<\\([^>]+\\)>" nil t)
+           (downcase-region (match-beginning 1) (match-end 1)))
+         )
+       )
 
 ;; If we enter html mode and there is no makefile around, create a
 ;; compilation command with tidy (this is cool stuff)
@@ -1730,54 +1884,71 @@ a file in /tmp"
 ;; Create the adequate embryo of a file if it does not exist
 
 (defun ff/start-file () (interactive)
-  (let ((filename (buffer-file-name)))
-    (when filename
-
-      (when (string-match "\\.sh$" filename)
-        (sh-mode)
-        (insert "#!/bin/bash\n\nset -e\n\n")
-        (save-excursion
-          (ff/add-copyrights))
-        )
+       (let ((filename (buffer-file-name)))
+         (when filename
+
+           (when (string-match "\\.sh$" filename)
+             (sh-mode)
+             (insert "#!/bin/bash\n\nset -e\nset -o pipefail\n\n")
+             (save-excursion
+               (ff/add-copyrights))
+             )
 
-      (when (string-match "\\.html$" filename)
-        (html-mode)
-        (ff/start-html)
-        (previous-line 4)
-        )
+           (when (string-match "\\.html$" filename)
+             (html-mode)
+             (ff/start-html)
+             (previous-line 4)
+             )
 
-      (when (string-match "\\.h$" filename)
-        (c++-mode)
-        (ff/headerize)
-        (save-excursion
-          (ff/add-copyrights)
-          (newline))
-        (newline)
-        (newline)
-        (previous-line 1)
-        )
+           (when (string-match "\\.h$" filename)
+             (c++-mode)
+             (ff/headerize)
+             (save-excursion
+               (ff/add-copyrights)
+               (newline))
+             (newline)
+             (newline)
+             (previous-line 1)
+             )
 
-      (when (string-match "\\.cc$" filename)
-        (c++-mode)
-        (ff/add-copyrights)
-        (let ((headername  (replace-regexp-in-string "\.cc" ".h" filename)))
-          (if (file-exists-p headername)
-              (insert (concat "\n#include \"" (file-name-nondirectory headername) "\"\n"))
-            (ff/start-c++))
-          ))
+           (when (string-match "\\.c$" filename)
+             (c-mode)
+             (ff/add-copyrights)
+             (ff/start-c))
+
+           (when (string-match "\.\\(cc\\|cpp\\)$" filename)
+             (c++-mode)
+             (ff/add-copyrights)
+             (let ((headername  (replace-regexp-in-string "\\.\\(cc\\|cpp\\)$" ".h"
+                                                          filename)))
+               (if (file-exists-p headername)
+                   (insert (concat "\n#include \"" (file-name-nondirectory headername) "\"\n"))
+                 (ff/start-c++))
+               ))
 
-      (when (string-match "\\.tex$" filename)
-        (latex-mode)
-        (ff/start-latex)
-        ))
-    )
-  (set-buffer-modified-p nil)
-  )
+           (when (string-match "\\.tex$" filename)
+             (latex-mode)
+             (ff/start-latex)
+             ))
+         )
+       (set-buffer-modified-p nil)
+       )
 
 (if (>= emacs-major-version 22)
     (add-to-list 'find-file-not-found-functions 'ff/start-file)
   (add-to-list 'find-file-not-found-hooks 'ff/start-file))
 
+(when (>= emacs-major-version 24)
+  (define-obsolete-function-alias 'make-local-hook 'ignore "21.1")
+  (setq send-mail-function 'sendmail-send-it) ;; emacs 24.x stuff
+
+  (custom-set-faces
+   '(diff-added ((default (:background "gray90" :foreground "green4" :weight bold))))
+   '(diff-removed ((default (:background "gray90" :foreground "red2" :weight bold))))
+   '(diff-changed ((default (:background "gray90" :foreground "blue" :weight bold))))
+   )
+  )
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (define-key global-map [f8] 'ff-find-other-file)
@@ -1835,7 +2006,7 @@ a file in /tmp"
     )
   )
 
-(setq compilation-finish-functions (cons 'ff/restore-windows-if-no-error compilation-finish-functions))
+(add-to-list 'compilation-finish-functions 'ff/restore-windows-if-no-error)
 
 (defun ff/fast-compile ()
   "Compiles without asking anything."
@@ -1850,14 +2021,14 @@ a file in /tmp"
       )
 
 (defun ff/universal-compile () (interactive)
-  (funcall (or (cdr (assoc major-mode
-                           '(
-                             (latex-mode . tex-file)
-                             (html-mode . browse-url-of-buffer)
-                             ;; Here you can add other mode -> compile command
-                             )))
-               'ff/fast-compile         ;; And this is the failsafe
-               )))
+       (funcall (or (cdr (assoc major-mode
+                                '(
+                                  (latex-mode . tex-file)
+                                  (html-mode . browse-url-of-buffer)
+                                  ;; Here you can add other mode -> compile command
+                                  )))
+                    'ff/fast-compile         ;; And this is the failsafe
+                    )))
 
 (define-key global-map [f1] 'ff/universal-compile)
 (define-key global-map [(shift f1)] 'compile)
@@ -1870,14 +2041,27 @@ a file in /tmp"
 ;; (when (ff/load-or-alert "flyspell-timer" t)
 ;;   (add-hook 'flyspell-mode-hook 'flyspell-timer-ensure-idle-timer))
 
+(defun ff/start-flyspell () (interactive)
+       (ff/configure-faces
+        '(
+          ;; (flyspell-incorrect :background "#ff0000" :foreground "black")
+          ;; (flyspell-duplicate :background "#ff9000" :foreground "black")
+          (flyspell-incorrect :foreground "#ff0000" :weight 'bold)
+          (flyspell-duplicate :foreground "#ff9000" :weight 'bold)
+          ))
+       ;; (flyspell-buffer)
+       )
+
+(add-hook 'flyspell-mode-hook 'ff/start-flyspell)
+
 (defun ff/pick-dictionnary () (interactive)
-  (when (and (boundp 'flyspell-mode) flyspell-mode)
-    (if (and current-input-method (string-match "latin" current-input-method))
-        (ispell-change-dictionary "francais")
-      (ispell-change-dictionary "american"))
-    ;;     (flyspell-buffer)
-    )
-  )
+       (when (and (boundp 'flyspell-mode) flyspell-mode)
+         (if (and current-input-method (string-match "latin" current-input-method))
+             (ispell-change-dictionary "francais")
+           (ispell-change-dictionary "american"))
+         ;;     (flyspell-buffer)
+         )
+       )
 
 (defadvice toggle-input-method (after ff/switch-dictionnary nil activate)
   (ff/pick-dictionnary))
@@ -1930,22 +2114,22 @@ This may be a useful alternative binding for \\[delete-other-windows]
 ;; Usefull to deal with results in latex files
 
 (defun ff/round-floats-in-region () (interactive)
-  (save-restriction
-    (condition-case nil
-        (narrow-to-region (region-beginning) (region-end))
-      (error (thing-at-point 'word)))
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward "[0-9\.]+" nil t)
-        (let ((value (string-to-number (buffer-substring (match-beginning 0) (match-end 0)))))
-          (delete-region (match-beginning 0) (match-end 0))
-          (insert (format "%0.2f" value)))))))
+       (save-restriction
+         (condition-case nil
+             (narrow-to-region (region-beginning) (region-end))
+           (error (thing-at-point 'word)))
+         (save-excursion
+           (goto-char (point-min))
+           (while (re-search-forward "[0-9\.]+" nil t)
+             (let ((value (string-to-number (buffer-substring (match-beginning 0) (match-end 0)))))
+               (delete-region (match-beginning 0) (match-end 0))
+               (insert (format "%0.2f" value)))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Keymaping
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(require 'info nil t)
+(load "info" nil t)
 
 (define-key global-map [(shift iso-lefttab)] 'ispell-complete-word)
 ;; shift-tab going backward is kind of standard
@@ -1996,32 +2180,6 @@ This may be a useful alternative binding for \\[delete-other-windows]
 
 ;; Closes the current \begin{}
 
-(add-hook 'latex-mode-hook (lambda () (define-key latex-mode-map [(control end)] 'tex-close-latex-block)))
-
-(when (ff/load-or-alert "longlines")
-
-  (setq longlines-show-hard-newlines t
-        longlines-auto-wrap t
-        longline-show-effect #(" -- |\n" 0 2 (face escape-glyph))
-        )
-
-  ;; (defun ff/auto-longlines ()
-  ;; (when (save-excursion
-  ;; (goto-char (point-min))
-  ;; (re-search-forward "^.\\{81,\\}$" nil t))
-  ;; (longlines-mode)
-  ;; (message "Switched on the lonlines mode automatically")
-  ;; ))
-
-  ;; (add-hook 'latex-mode-hook 'ff/auto-longlines)
-
-  )
-
-(add-hook 'latex-mode-hook
-          (lambda ()
-            (define-key latex-mode-map [(control tab)]
-              'ispell-complete-word)))
-
 ;; Meta-/ remaped (completion)
 
 (define-key global-map [(shift right)] 'dabbrev-expand)
@@ -2030,14 +2188,14 @@ This may be a useful alternative binding for \\[delete-other-windows]
 ;; Change the current window.
 
 (defun ff/next-same-frame-window () (interactive)
-  (select-window (next-window (selected-window)
-                              (> (minibuffer-depth) 0)
-                              nil)))
+       (select-window (next-window (selected-window)
+                                   (> (minibuffer-depth) 0)
+                                   nil)))
 
 (defun ff/previous-same-frame-window () (interactive)
-  (select-window (previous-window (selected-window)
-                                  (> (minibuffer-depth) 0)
-                                  nil)))
+       (select-window (previous-window (selected-window)
+                                       (> (minibuffer-depth) 0)
+                                       nil)))
 
 (define-key global-map [(shift prior)] 'ff/next-same-frame-window)
 (define-key global-map [(shift next)] 'ff/previous-same-frame-window)
@@ -2051,19 +2209,19 @@ This may be a useful alternative binding for \\[delete-other-windows]
 ;; (define-key global-map [(control shift next)] 'previous-multiframe-window)
 
 ;; I have two screens sometime!
+;; (define-key global-map [(meta next)] 'other-frame)
+;; (define-key global-map [(meta prior)] (lambda () (interactive) (other-frame -1)))
 
-(define-key global-map [(meta next)] 'other-frame)
-(define-key global-map [(meta prior)] (lambda () (interactive) (other-frame -1)))
-
-(define-key global-map [(shift home)] 'delete-other-windows-vertically)
+;; (load "winner")
+(winner-mode 1)
+(define-key global-map [(shift backspace)] 'winner-undo)
 
+;; (define-key global-map [(shift home)] 'delete-other-windows-vertically)
 ;; (define-key global-map [(control +)] 'enlarge-window)
 ;; (define-key global-map [(control -)] 'shrink-window)
-
 ;; Goes to next/previous buffer
-
-(define-key global-map [(control prior)] 'ff/next-buffer)
-(define-key global-map [(control next)] 'ff/prev-buffer)
+;; (define-key global-map [(control prior)] 'ff/next-buffer)
+;; (define-key global-map [(control next)] 'ff/prev-buffer)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; If M-. on a symbol, show where it is defined in another window
@@ -2073,12 +2231,12 @@ This may be a useful alternative binding for \\[delete-other-windows]
 (when (ff/load-or-alert "etags")
 
   (defun ff/find-tag-nofocus () (interactive)
-    "Show in another window the definition of the current tag"
-    (let ((tag (find-tag-default)))
-      (display-buffer (find-tag-noselect tag (string= tag last-tag)))
-      (message "Tag %s" tag)
-      )
-    )
+         "Show in another window the definition of the current tag"
+         (let ((tag (find-tag-default)))
+           (display-buffer (find-tag-noselect tag (string= tag last-tag)))
+           (message "Tag %s" tag)
+           )
+         )
 
   (define-key global-map [(meta .)] 'ff/find-tag-nofocus)
   )
@@ -2111,7 +2269,7 @@ next one. With universal argument, kill all killable buffers."
     (if (string-match ff/kill-this-buffer-and-delete-window-exceptions (buffer-name))
         (ff/next-buffer)
       (kill-this-buffer)))
-  ;; (unless (one-window-p t) (delete-window))
+  (unless (one-window-p t) (delete-window))
   )
 
 (define-key global-map [(control backspace)] 'ff/kill-this-buffer-and-delete-window)
@@ -2138,42 +2296,38 @@ next one. With universal argument, kill all killable buffers."
     (message "elisp debug off")))
 
 (defun ff/create-dummy-buffer (&optional universal) (interactive "P")
-  (find-file (concat "/tmp/" (ff/non-existing-filename "/tmp/" "dummy" "")))
-  (text-mode)
-  (if universal (ff/insert-url (current-kill 0)))
-  (message "New dummy text-mode buffer"))
+       (find-file (concat "/tmp/" (ff/non-existing-filename "/tmp/" "dummy" "")))
+       (text-mode)
+       (if universal (ff/insert-url (current-kill 0)))
+       (message "New dummy text-mode buffer"))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Recentf to keep a list of recently visited files. I use it
 ;; exclusively with my selector.el
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(require 'recentf)
+(load "recentf")
+
+;; If we just check for file-symlink-p, everytime we start emacs it
+;; will check all the remote files listed in recentf-list, so we check
+;; that they are not remote first
+(defun ff/file-not-remote-but-symlink (filename)
+  (and (not (file-remote-p filename)) (file-symlink-p filename)))
 
-(setq recentf-exclude
-      (append recentf-exclude
-              '("enotes$" "secure-notes$" "media-playlists$"
-                "bbdb$"
-                "svn-commit.tmp$" ".git/COMMIT_EDITMSG$"
-                "\.bbl$" "\.aux$" "\.toc$"))
+(setq recentf-exclude (append recentf-exclude
+                              '(
+                                ff/file-not-remote-but-symlink
+                                "enotes$" "secure-notes$" "media-playlists$"
+                                "bbdb$"
+                                "svn-commit.tmp$" ".git/COMMIT_EDITMSG$"
+                                "\.bbl$" "\.aux$" "\.toc$"
+                                ))
       recentf-max-saved-items 1000
-      recentf-save-file "~/private/emacs/recentf"
+      recentf-save-file (concat ff/emacs-dir "/recentf")
       )
 
 (when (boundp 'recentf-keep) (add-to-list 'recentf-keep 'file-remote-p))
 
-;; Removes the link if we add the file itself (I am fed up with
-;; duplicates because of vc-follow-symlinks)
-
-(defadvice recentf-add-file (before ff/remove-links (filename) activate)
-  ;; If we are adding a filename corresponding to the last link we
-  ;; have added, remove the latter
-  (when (and recentf-list
-             (file-symlink-p (car recentf-list))
-             (string= filename (file-chase-links filename)))
-    (setq recentf-list (cdr recentf-list))
-    ))
-
 (recentf-mode 1)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2186,11 +2340,17 @@ next one. With universal argument, kill all killable buffers."
 (when (ff/load-or-alert "media")
 
   (unless window-system
-    (ff/configure-faces '(
-                          (media/mode-string-face :foreground "blue4" :weight 'bold)
-                          (media/current-tune-face :foreground "black" :background "yellow" :weight 'normal)
-                          (media/instant-highlight-face :foreground "black" :background "orange" :weight 'normal)
-                          ))
+    (ff/configure-faces
+     '(
+       (media/mode-string-face
+        :foreground "blue4" :weight 'bold)
+
+       (media/current-tune-face
+        :foreground "black" :background "yellow" :weight 'normal)
+
+       (media/instant-highlight-face
+        :foreground "black" :background "orange" :weight 'normal)
+       ))
     )
 
   (define-key global-map [(meta \\)] 'media)
@@ -2199,14 +2359,16 @@ next one. With universal argument, kill all killable buffers."
         media/add-current-song-to-interrupted-when-killing t
         media/duration-to-history 30
         media/history-size 1000
-        media/playlist-file "~/private/emacs/media-playlists"
+        media/playlist-file (concat ff/emacs-dir "/media-playlists")
         media/mplayer/args '(
                              "-framedrop"
                              "-zoom"
+                             "-cache" "512"
                              "-subfont-osd-scale" "3"
+                             ;; "-stop-xscreensaver"
                              ;; "-osdlevel" "3"
                              )
-        media/mplayer/timing-request-period 5.0
+        media/mplayer/timing-request-period 1.0
         )
   )
 
@@ -2217,7 +2379,7 @@ next one. With universal argument, kill all killable buffers."
 ;; selector.el is one of my own scripts, check my web page
 
 (when (ff/load-or-alert "selector" t)
-  (define-key global-map [(shift return)] 'selector/quick-move-in-buffer)
+  ;; (define-key global-map [(shift return)] 'selector/quick-move-in-buffer)
   (define-key global-map [(control x) (control b)] 'selector/switch-buffer)
 
   (defun ff/visit-debpkg-file (&optional regexp)
@@ -2252,22 +2414,36 @@ proposes to visit them."
   )
 
 (defun ff/selector-mail-from-bbdb () (interactive)
-  (selector/select
-   (mapcar
-    (lambda (r) (cons (concat (elt r 0)
-                              " "
-                              (elt r 1)
-                              " ("
-                              (car (elt r 6))
-                              ")")
-                      r))
-    (bbdb-records))
-   (if (string= mode-name "Mail")
-       'ff/selector-insert-record-callback
-     'ff/selector-compose-mail-callback)
-   "*bbdb-search*"
-   )
-  )
+       (selector/select
+        (mapcar
+         (lambda (r) (cons (concat (elt r 0)
+                                   " "
+                                   (elt r 1)
+                                   " ("
+                                   (car (elt r 6))
+                                   ")")
+                           r))
+         (bbdb-records))
+        (if (string= mode-name "Mail")
+            'ff/selector-insert-record-callback
+          'ff/selector-compose-mail-callback)
+        "*bbdb-search*"
+        )
+       )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; My script to automatically count the number of words and characters
+;; between two markers
+
+(ff/load-or-alert "text-counters.el")
+
+;; Display them in the modeline when in text-mode
+
+(add-hook 'text-mode-hook 'tc/add-text-counters-in-modeline)
+
+;; (add-hook 'text-mode-hook
+;; (lambda ()
+;; (setq comment-start " > ")))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; A function to remove temporary alarm windows
@@ -2303,37 +2479,82 @@ proposes to visit them."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defun ff/twin-horizontal-current-buffer () (interactive)
-  (delete-other-windows)
-  (split-window-horizontally)
-  (balance-windows)
-  )
+       (delete-other-windows)
+       (split-window-horizontally)
+       (balance-windows)
+       )
 
 (defun ff/twin-vertical-current-buffer () (interactive)
-  (delete-other-windows)
-  (split-window-vertically)
-  (balance-windows)
-  )
+       (delete-other-windows)
+       (split-window-vertically)
+       (balance-windows)
+       )
 
 (defun ff/flyspell-mode (arg) (interactive "p")
-  (flyspell-mode)
-  (when flyspell-mode (flyspell-buffer)))
+       (if flyspell-mode (flyspell-mode -1)
+         (flyspell-mode 1)
+         (flyspell-buffer))
+       )
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; The fridge!
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun ff/move-region-to-fridge () (interactive)
+       "Cut the current region, paste it in a file called ./fridge
+with a time tag, and save this file"
+       (unless (use-region-p) (error "No region selected"))
+       (let ((bn (file-name-nondirectory (buffer-file-name))))
+         (kill-region (region-beginning) (region-end))
+         (with-current-buffer (find-file-noselect "fridge")
+           (goto-char (point-max))
+           (insert "\n")
+           (insert "######################################################################\n")
+           (insert "\n"
+                   (format-time-string "%Y %b %d %H:%M:%S" (current-time))
+                   " (from "
+                   bn
+                   ")\n\n")
+           (yank)
+           (save-buffer)
+           (message "Region moved to fridge")
+           )
+         )
+       )
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; My own keymap
+;; My own keymap mapped to C-`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (setq ff/map (make-sparse-keymap))
 (define-key global-map [(control \`)] ff/map)
+
+(unless window-system
+  ;; (define-key global-map [(control @)] ff/map)
+  (define-key global-map [(meta O) \`] ff/map)
+  )
+
 (define-key esc-map "`" ff/map)
 
 (defun ff/git-status (&optional dir) (interactive)
-  (if (buffer-file-name)
-      (git-status (file-name-directory (buffer-file-name)))
-    (error "No file attached to this buffer")))
+       (if (buffer-file-name)
+           (git-status (file-name-directory (buffer-file-name)))
+         (error "No file attached to this buffer")))
+
+(defun ff/insert-date (&optional universal) (interactive "P")
+       ;; (insert (format-time-string "\n * %Y %b %d %H:%M:%S\n\n" (current-time)))
+       ;; (insert (format-time-string "%Y %b %d %H:%M:%S" (current-time)))
+       ;; (insert (format-time-string "%d.%m.%y" (current-time)))
+       (if universal
+           (insert (format-time-string "%d.%m.%Y %H:%M:%S" (current-time)))
+         (insert (format-time-string "%d.%m.%Y" (current-time))))
+       )
 
 (define-key ff/map [(control g)] 'ff/git-status)
 (define-key ff/map [(control w)] 'server-edit)
 (define-key ff/map [(control d)] 'ff/elisp-debug-on)
+;; (define-key ff/map "d" 'diary)
+(define-key ff/map "d" 'ff/insert-date)
 (define-key ff/map [(control \`)] 'ff/bash-new-buffer)
 (define-key ff/map [(control n)] 'enotes/show-all-notes)
 (define-key ff/map [(control s)] 'ff/secure-note-add)
@@ -2345,9 +2566,11 @@ proposes to visit them."
 (define-key ff/map [(control c)] 'calendar)
 ;; (define-key ff/map [(control c)] (lambda () (interactive) (save-excursion (calendar))))
 (define-key ff/map [(control l)] 'goto-line)
+(define-key ff/map "l" 'longlines-mode)
 (define-key ff/map [(control o)] 'selector/quick-pick-recent)
 (define-key ff/map "s" 'selector/quick-move-in-buffer)
 (define-key ff/map "S" 'selector/search-sentence)
+(define-key ff/map "t" (lambda () (interactive) (find-file "~/private/TODO.txt")))
 (define-key ff/map "h" 'ff/tidy-html)
 (define-key ff/map "c" 'ff/count-char)
 (define-key ff/map [(control p)] 'ff/print-to-file)
@@ -2361,6 +2584,7 @@ proposes to visit them."
   (lambda () (interactive)
     (bookmark-set)
     (bookmark-save)))
+(define-key ff/map "f" 'ff/move-region-to-fridge)
 (define-key ff/map [(control f)] 'ff/flyspell-mode)
 
 (define-key ff/map [?\C-0] 'ff/delete-annoying-windows)
@@ -2371,6 +2595,8 @@ proposes to visit them."
 (define-key ff/map "3" 'ff/twin-horizontal-current-buffer)
 (define-key ff/map [?\C-3] 'ff/twin-horizontal-current-buffer)
 
+(define-key ff/map " " 'delete-trailing-whitespace)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Hacks so that all keys are functionnal in xterm and through ssh.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2381,30 +2607,30 @@ proposes to visit them."
   ;; so that it works in xterm (yes), let's use xclip. This is a bit
   ;; ugly.
 
-  (defun ff/yank-with-xclip (&optional arg)
-    "Paste the content of the X clipboard with the xclip
-command. Without ARG converts some of the '\\uxxxx' characters."
-    (interactive "P")
-    (with-temp-buffer
-      (shell-command "xclip -o" t)
-      (unless arg
-        (mapc (lambda (x) (replace-string (concat "\\u" (car x)) (cdr x) nil (point-min) (point-max)))
-              '(("fffd" . "??")
-                ("2013" . "-")
-                ("2014" . "--")
-                ("2018" . "`")
-                ("2019" . "'")
-                ("201c" . "``")
-                ("201d" . "''")
-                ("2022" . "*")
-                ("2026" . "...")
-                ("20ac" . "EUR")
-                )))
-      (kill-ring-save (point-min) (point-max)))
-
-    (yank))
-
-  (define-key global-map [(meta y)] 'ff/yank-with-xclip)
+  ;; (defun ff/yank-with-xclip (&optional arg)
+  ;; "Paste the content of the X clipboard with the xclip
+  ;; command. Without ARG converts some of the '\\uxxxx' characters."
+  ;; (interactive "P")
+  ;; (with-temp-buffer
+  ;; (shell-command "xclip -o" t)
+  ;; (unless arg
+  ;; (mapc (lambda (x) (replace-string (concat "\\u" (car x)) (cdr x) nil (point-min) (point-max)))
+  ;; '(("fffd" . "??")
+  ;; ("2013" . "-")
+  ;; ("2014" . "--")
+  ;; ("2018" . "`")
+  ;; ("2019" . "'")
+  ;; ("201c" . "``")
+  ;; ("201d" . "''")
+  ;; ("2022" . "*")
+  ;; ("2026" . "...")
+  ;; ("20ac" . "EUR")
+  ;; )))
+  ;; (kill-ring-save (point-min) (point-max)))
+
+  ;; (yank))
+
+  ;; (define-key global-map [(meta y)] 'ff/yank-with-xclip)
 
   ;;   (set-terminal-coding-system 'iso-latin-1)
   ;; (set-terminal-coding-system 'utf-8)
@@ -2537,16 +2763,18 @@ With argument ARG, do this that many times."
 
 ;; Where to save the bookmarks and where is bbdb
 
-(setq bookmark-default-file "~/private/emacs/bmk"
+(setq bookmark-default-file (concat ff/emacs-dir "/bmk")
       bbdb-file "~/private/bbdb"
-      custom-file "~/private/emacs/custom")
+      custom-file (concat ff/emacs-dir "/custom"))
 
 ;; enotes.el is one of my own scripts, check my web page
 
 (when (ff/load-or-alert "enotes" t)
   (setq enotes/file "~/private/enotes"
         enotes/show-help nil
-        enotes/full-display nil)
+        enotes/full-display nil
+        enotes/default-time-fields "9:30")
+
   (enotes/init)
   ;; (add-hook 'enotes/alarm-hook
   ;;  (lambda () (ff/play-sound-async "~/local/sounds/three_notes2.wav")))