From 6416868628cb18f5a55d685c464ab99b54e0077f Mon Sep 17 00:00:00 2001
From: Francois Fleuret <francois@fleuret.org>
Date: Sat, 22 Aug 2015 16:43:51 +0200
Subject: [PATCH] Updated the thermal and battery info display for the T450s

---
 emacs.el | 625 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 327 insertions(+), 298 deletions(-)

diff --git a/emacs.el b/emacs.el
index 0ea7c14..0a8ca7d 100644
--- a/emacs.el
+++ b/emacs.el
@@ -31,6 +31,13 @@
 ;; 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))
 
@@ -268,8 +275,8 @@ load-warning buffer in case of failure."
 (blink-cursor-mode 0)
 
 ;; (setq blink-cursor-delay 0.05
-      ;; blink-cursor-blinks 0
-      ;; blink-cursor-interval 0.25)
+;; blink-cursor-blinks 0
+;; blink-cursor-interval 0.25)
 
 ;; (set-terminal-coding-system 'utf-8)
 
@@ -798,10 +805,12 @@ printer."
 ;; Dealing with the laptop battery
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defcustom ff/battery-dir "/sys/class/power_supply/BAT0"
+(defcustom ff/battery-dirs '("/sys/class/power_supply/BAT0"
+                             "/sys/class/power_supply/BAT1")
   "*Where to gather the battery information")
 
-(defcustom ff/temperature-file "/sys/class/thermal/thermal_zone0/temp"
+(defcustom ff/temperature-files '("/sys/class/thermal/thermal_zone0/temp"
+                                  "/sys/class/thermal/thermal_zone1/temp")
   "*Where to gather the thermal information")
 
 (defun ff/file-first-line (file)
@@ -809,99 +818,117 @@ printer."
     (insert-file-contents-literally file)
     (buffer-substring (point-at-bol) (point-at-eol))))
 
-(defun ff/battery-percent (prefix)
+(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))
+
+(defun ff/sum-numbers (list-files prefix)
+  (apply '+
+         (mapcar
+          (lambda (f) (string-to-number (ff/file-first-line (format "%s/%s" f prefix))))
+          list-files)))
+
+(defun ff/battery-percent ()
   (condition-case nil
-      (/ (* 100 (string-to-number (ff/file-first-line (format "%s/%s_now" ff/battery-dir prefix))))
-         (string-to-number (ff/file-first-line (format "%s/%s_full"  ff/battery-dir prefix))))
+      (/ (* 100 (ff/sum-numbers ff/battery-dirs "energy_now"))
+         (ff/sum-numbers ff/battery-dirs "energy_full"))
     (error -1))
   )
 
-(defun ff/laptop-info-string () (interactive)
-  (condition-case nil
-      (concat
-
-       ;; The temperature
+(defun ff/temp-and-battery-info-string () (interactive)
+       (condition-case nil
+           (concat
 
-       (let ((temp (/ (string-to-number (ff/file-first-line ff/temperature-file)) 1000)))
-         (if (> temp 50)
-             (concat
-              (let ((s (format "%dC " temp)))
-                (if (> temp 70) (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)
+                  (concat
+                   (let ((s (format "%dC " temp)))
+                     (if (> temp 70) (propertize s 'face
+                                                 'font-lock-warning-face)
+                       s))
+                   )
+                )
               )
-           )
-         )
-
-       ;; The battery
 
-       (let ((battery-status (ff/file-first-line (concat ff/battery-dir "/status"))))
+            ;; The battery
 
-         (cond
-          ((string= battery-status "Full") "L")
+            (pcase (ff/battery-state ff/battery-dirs)
+              (`charging (format "L%d%%" (ff/battery-percent)))
+              (`discharging (format "B%d%%" (ff/battery-percent)))
+              (code "L"))
 
-          ((string= battery-status "Charging")
-           (format "L%d%%" (max (ff/battery-percent "charge")
-                                (ff/battery-percent "energy"))))
-
-          ((string= battery-status "Discharging")
-           (let* ((c (max (ff/battery-percent "charge")
-                          (ff/battery-percent "energy")))
-                  (s (format "B%d%%" c)))
-             (if (>= c 20) s (propertize s 'face 'font-lock-warning-face))))
-
-          (t battery-status)
-
-          ))
+            )
 
+         (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 '(:background "#c0c0ff"))
-                 (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 "-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)
+         ))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Make a sound when there is new mail
@@ -947,8 +974,8 @@ printer."
 
                              load
 
-                             ,(if (ff/laptop-info-string)
-                                  '(concat " " (ff/laptop-info-string)))
+                             ,(if (ff/temp-and-battery-info-string)
+                                  '(concat " " (ff/temp-and-battery-info-string)))
 
                              )
 
@@ -985,6 +1012,8 @@ printer."
 
 (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-'] 'ff/next-buffer)
+(define-key global-map [?\C-\;] 'ff/prev-buffer)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; There is actually a decent terminal emulator in emacs!
@@ -993,15 +1022,15 @@ 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)))
+       (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,
@@ -1238,32 +1267,32 @@ ff/known-address-face is used."
 
 (defun ff/secure-note-add () (interactive)
 
-  (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)
-  )
+       (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)
+         )
 
-  ;; 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))))
-
-  (set-buffer-modified-p nil)
-  (setq buffer-undo-list nil)
-  )
+       (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))))
+
+       (set-buffer-modified-p nil)
+       (setq buffer-undo-list nil)
+       )
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Spelling
@@ -1427,13 +1456,13 @@ universal argument starts xfig even if the .fig does not exist"
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (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."
@@ -1527,12 +1556,12 @@ universal argument starts xfig even if the .fig does not exist"
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (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"))
-    ))
+       (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."
@@ -1764,26 +1793,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)
@@ -1834,55 +1863,55 @@ 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\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 "\\.h$" filename)
-        (c++-mode)
-        (ff/headerize)
-        (save-excursion
-          (ff/add-copyrights)
-          (newline))
-        (newline)
-        (newline)
-        (previous-line 1)
-        )
-
-      (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++))
-          ))
+       (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 "\\.h$" filename)
+             (c++-mode)
+             (ff/headerize)
+             (save-excursion
+               (ff/add-copyrights)
+               (newline))
+             (newline)
+             (newline)
+             (previous-line 1)
+             )
+
+           (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)
@@ -1971,14 +2000,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)
@@ -1992,26 +2021,26 @@ a file in /tmp"
 ;;   (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)
-  )
+       (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))
@@ -2064,16 +2093,16 @@ 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
@@ -2160,14 +2189,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)
@@ -2203,12 +2232,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)
   )
@@ -2268,10 +2297,10 @@ 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
@@ -2386,22 +2415,22 @@ 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
@@ -2414,8 +2443,8 @@ proposes to visit them."
 (add-hook 'text-mode-hook 'tc/add-text-counters-in-modeline)
 
 ;; (add-hook 'text-mode-hook
-          ;; (lambda ()
-            ;; (setq comment-start " > ")))
+;; (lambda ()
+;; (setq comment-start " > ")))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; A function to remove temporary alarm windows
@@ -2451,48 +2480,48 @@ 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")
-  (if flyspell-mode (flyspell-mode -1)
-    (flyspell-mode 1)
-    (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
+       "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")
-      )
-    )
-  )
+       (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 mapped to C-`
@@ -2509,14 +2538,14 @@ with a time tag, and save this file"
 (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)))
+       ;; (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))))
-- 
2.20.1