Everything with Emacs

;; General help
(defun help-exit ()
  (interactive) ;;required for local-set-key
  (quit-window t))

;; Help buffer
(defun show-help ()
  (interactive)
  (let ((buffer (get-buffer-create (format "*help.in"))))
    (switch-to-buffer buffer)
    (setq buffer-read-only nil)
    (erase-buffer)
    (insert "
----------------------
HELP (press q to exit)
----------------------

BUFFERS
-------
<C-escape>:     kill buffer (S: kill buffer and window)
<C-backspace>:  kill all invisible buffers
<C-x C-b>:      list buffers

WORKFLOW
--------
<C-c d>:    note taking (deft)
<C-c c>:    capture menu
<C-c x>:    capture bibtexendum
<C-x C-f>:  create/find file
<C-c i>:    load template
<C-x C-T>:  terminal here
<C-x C-t>:  terminal (dedicated)
<C-x g>:    magit-status
<C-x B>:    helm-bibtex (r: resume, C-g: exit)
<C-x p>:    helm-bibtex (my publications)
M-x lcalc:  literate calculation (also, quick-calc, calc & calculator)

HYDRAS
------
<C-c z>:    zoom/font actions
<C-c m>:    move actions (move, goto line...)
<C-c t>:    toggle actions (browser, whitespace, dicts...)
<C-c f>:    file action (file size, filename...)

EDITING
-------
<C-c p>:    parentheses actions
<C-c r>:    region actions (count, unfill, spell...)
<C-c w>:    word actions (spell, case, translate, lookup...)
<?> in PDF: pdf actions (annotate, goto...)
<f2>:       spell correct (C-f2: next)
<C-.>:      auto-correct
<C-space>:  start selection, continue with arrows (C-g to cancel)

MISC
----
<f1>:     general help (C: specific mode help)
<C-c e>:  reload .emacs
<C-x u>:  undo tree vizualizer
<C-c b>:  show bookmarks
<C-c T>:  world clock

SEARCH/REPLACE
--------------
<C-c s>:     search actions (search, occur...)
<C-s>:       iSearch (r: backwards)
<M-%>:       replace
M-x locate:  locate (use * first if using wildcards)

KILL-RING
---------
<C-y>:       paste (yank) repeat for kill-ring (C-S-y: unfill and add double-quotes as well)
<M-y>:       show kill-ring

M-x commands
------------
M-x quick-calc:  simple calculation
M-x calculator:  calculator (use ' for algebraic mode, u-v for units, =/u-b for value, u-c for conversion)

LAYOUTS
-------
<C-c l>:  layouts (incl. org/pdf)
<f8>:     winner undo (C: redo)
<f2>:     ranger

EIN
---
py & C-f7:    insert block snippet
M-x ein:run : launch ein
<C-c C-o>:    open dir
<C-x C-s>:    save
<C-x C-w>:    rename
<C-c C-a>:    insert cell above
<C-c C-b>:    insert cell below
<C-c C-k>:    kill cell
<C-c C-c>:    execute
<M-RET>  :    execute and next cell
<CM-arrows>:  move

MULTIPLE-CURSORS
----------------
<C-S-c C-S-c>: cursors on selected region
<C-S-mouse-1>: place cursors with mouse

ZATHURA
-------
/,?:   search forward/backward
n,N:   search last keyword forward/backward
<TAB>: index
r:     rotate
gg/GG: goto first/last page

")

    (setq buffer-read-only t)
    (local-set-key "q" 'help-exit)
    )
  )

(global-set-key (read-kbd-macro "<f1>") 'show-help)

;; hydra to choose layout
(global-set-key (kbd "\C-cl")
                (defhydra hydra-layouts
                  (:exit t)
                  "layouts"
                  ("w" org-layout-work "all indiv.")
                  ("m" mu4e-elfeed "mu4e+elfeed")
                  ("W" show-workflow "workflow")
                  ("b" show-bookmarks "bookmarks")
                  ("d" dired-layout "dired")
                  ("D" dired-layout2 "dired bis")
                  ("f" elfeed-load "elfeed")
                  ("p" orgpdf-layout "org/pdf" :color blue)
                  ("y" elpy-layout "elpy")
                  ))

;;; Emacs is not a package manager, and here we load its package manager!
(require 'package)

(add-to-list 'package-archives
             '("melpa-stable" . "https://stable.melpa.org/packages/") t)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/") t)
;(add-to-list 'package-archives
;             '("marmalade" . "https://marmalade-repo.org/packages/") t)

;; automatically update the list of packages
(when (not package-archive-contents)
  (package-refresh-contents))

;;gpg signatures on list-packages
(setq package-check-signature nil)

;; Save initial launch directory
(setq launch-directory default-directory)

;; Turn on visible bell
(setq visible-bell t)
(setq ring-bell-function 'ignore)

;; No startup screen
(setq inhibit-startup-screen t)
(setq inhibit-startup-message t)
(setq inhibit-startup-echo-area-message t)
(setq initial-scratch-message nil)

(defun display-startup-echo-area-message ()
  (message ""))

;; Removes *scratch* from buffer after the mode has been set
                                        ;(defun remove-scratch-buffer ()
                                        ;  (if (get-buffer "*scratch*")
                                        ;      (kill-buffer "*scratch*")))
                                        ;(add-hook 'after-change-major-mode-hook 'remove-scratch-buffer)

;; Removes *messages* from the buffer.
;; (setq-default message-log-max nil)
;; (kill-buffer "*Messages*")

;; Removes *Completions* from buffer after you've opened a file.
(add-hook 'minibuffer-exit-hook
          '(lambda ()
             (let ((buffer "*Completions*"))
               (and (get-buffer buffer)
                    (kill-buffer buffer)))))

;; Don't show *Buffer list* when opening multiple files at the same time.
(setq inhibit-startup-buffer-menu t)

;; replace buffer list
(global-set-key (kbd "C-x C-b") 'ibuffer)
;;or (global-set-key [remap list-buffers] 'ibuffer)

;; text mode is default for new buffers
(setq-default major-mode 'text-mode)

;; Transparently open compressed files
(auto-compression-mode t)

;; Bottom-line function:
(defun bottom-line ()
  "Opens a file with the pointer at the bottom line."
  (interactive)
  (end-of-buffer))

;; Hook for every file opened, execute the bottom-line function:
(add-hook 'find-file-hook 'bottom-line)

;; Reload .emacs init file
(defun reload-init-file ()
  (interactive)
  (load-file user-init-file))
(global-set-key (kbd "C-c e") 'reload-init-file)

;;garbage collection
(add-hook 'focus-out-hook #'garbage-collect)

;; save history for minibuffer
(setq savehist-additional-variables    ;; also save...
      '(search-ring regexp-search-ring)    ;; ... my search entries
      ;;savehist-file "~/.emacs.d/savehist"
      ) ;; keep my home clean
(savehist-mode t)                      ;; do customization before activate

;; saved files
;(setq backup-directory-alist `((".*" . ,"~/.emacs_saves")))
;(setq auto-save-file-name-transforms `((".*" ,"~/emacs_saves" t)))
;(setq backup-by-copying t)
;(setq delete-old-versions t
;      kept-new-versions 6
;      kept-old-versions 2
;      version-control t)

;; saving after each save!
;; by default, Emacs never backs up versioned files. Since we’re going to be backing up intermediate copies, we want to backup versioned files too, since we don’t commit on every save:
(setq vc-make-backup-files t)

(setq version-control t ;; Use version numbers for backups.
        kept-new-versions 10 ;; Number of newest versions to keep.
        kept-old-versions 0 ;; Number of oldest versions to keep.
        delete-old-versions t ;; Don't ask to delete excess backup versions.
        backup-by-copying t) ;; Copy all files, don't rename them.
;; Default and per-save backups go here:
(setq backup-directory-alist '(("" . "~/.emacs_saves/backup/per-save")))

(defun force-backup-of-buffer ()
    ;; Make a special "per session" backup at the first save of each
    ;; emacs session.
    (when (not buffer-backed-up)
      ;; Override the default parameters for per-session backups.
      (let ((backup-directory-alist '(("" . "~/.emacs_saves/backup/per-session")))
            (kept-new-versions 3))
        (backup-buffer)))
    ;; Make a "per save" backup on each save.  The first save results in
    ;; both a per-session and a per-save backup, to keep the numbering
    ;; of per-save backups consistent.
    (let ((buffer-backed-up nil))
      (backup-buffer)))

;; backup before save
(add-hook 'before-save-hook  'force-backup-of-buffer)

;; If you want to avoid 'backup-by-copying', you can instead use
;;
;; (setq backup-by-copying-when-linked t)
;;
;; but that makes the second, "per save" backup below not run, since
;; buffers with no backing file on disk are not backed up, and
;; renaming removes the backing file.  The "per session" backup will
;; happen in any case, you'll just have less consistent numbering of
;; per-save backups (i.e. only the second and subsequent save will
;; result in per-save backups).

;; If you want to avoid backing up some files, e.g. large files,
;; then try setting 'backup-enable-predicate'.  You'll want to
;; extend 'normal-backup-enable-predicate', which already avoids
;; things like backing up files in '/tmp'.


;; recent files
;;(recentf-mode 1)
;;(setq recentf-max-menu-items 50)
;;(global-set-key "\C-x\ \C-r" 'recentf-open-files)
;;(run-at-time nil (* 5 60) 'recentf-save-list) ;;update every 5 mins (otherwise when emacs exits)

;; override the default "-c" (execute the following command). The addition of "-i" forces the bash shell into interactive mode, which leads to the sourcing of ~/.bashrc
;;(setq shell-command-switch "-ic")

(require 'hlinum)
(hlinum-activate)

;; Change "yes or no" to "y or n"
(fset 'yes-or-no-p 'y-or-n-p)

;; Don't ask for confirmation for "dangerous" commands
(put 'erase-buffer 'disabled nil)
(put 'narrow-to-page 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'scroll-left 'disabled nil)
(put 'scroll-right 'disabled nil)
(put 'set-goal-column 'disabled nil)

;; large file warning
(setq large-file-warning-threshold (* 15 1024 1024))

;; hydra toggle
(global-set-key (kbd "\C-ct")
                (defhydra hydra-toggle 
                  (:exit t)
                  "toggle"
                  ("df" (lambda () (interactive) (ispell-change-dictionary "fr_FR") (flyspell-buffer)) "french")
                  ("de" (lambda () (interactive) (ispell-change-dictionary "en_US") (flyspell-buffer)) "english")
                  ("g" guess-language-mode "guess-language") 
                                        ;("m" (lambda () (interactive) (ispell-change-dictionary "en_US,fr_FR") (ispell-set-spellchecker-params) (ispell-hunspell-add-multi-dic "en_US,fr_FR") (flyspell-buffer)) "mixed")
                  ("(" rainbow-delimiters-mode "Rainbow()") 
                  ("w" whitespace-mode "whitespace")
                  ;;("d" switch-dictionary "dictionary")
                  ("b" toggle-browser "browser")
                  ("s" symon-mode "symon")
                  ("W" global-visual-line-mode "wordwrap")
                  ("S" scroll-all-mode "scroll-all")
                  ("n" number-separator-mode "number-separator")
                  ("q" nil "cancel" :color blue)))

;; auto refresh (will still ask for confirmation if conflict)
(global-auto-revert-mode 1)

;; enable for image mode too (dired done below)
(add-hook 'image-mode-hook 'auto-revert-mode)

;; nice to be able to see when a file actually ends. This will put empty line markers into the left hand side. 
(setq-default indicate-empty-lines t)
(when (not indicate-empty-lines)
  (toggle-indicate-empty-lines))

;; Scrolling done right
(setq scroll-error-top-bottom t)

;; Number of lines of continuity when scrolling by screenfulls
(setq next-screen-context-lines 0)

(setq-default 
 scroll-conservatively most-positive-fixnum       ; Always scroll by one line
 )

;;Page scrolling should keep the point at the same visual position, rather than force it to the top or bottom of the viewport. This eliminates the friction of guessing where the point has warped to.
(setq scroll-preserve-screen-position t)

;; Show keystrokes in progress
(setq echo-keystrokes 0.1)

;; make cursor the width of the character it is under
;; i.e. full width of a TAB
(setq x-stretch-cursor t)

;; Bar cursor
;;(setq-default cursor-type '(bar . 2))
;; Don't blink the cursor
(blink-cursor-mode 0)

;;(setq-default cursor-type '(hollow . 1)) ;; 'hollow
(setq default-cursor-type 'box)

(setq default-frame-alist
      '((cursor-color . "yellow")))

;; ;; blink b&w
;; (defvar blink-cursor-colors (list  "#FFF" "#000" )
;;   "On each blink the cursor will cycle to the next color in this list.")

;; (setq blink-cursor-count 0)
;; (defun blink-cursor-timer-function ()
;;   "Zarza wrote this cyberpunk variant of timer `blink-cursor-timer'. 
;; Warning: overwrites original version in `frame.el'.

;; This one changes the cursor color on each blink. Define colors in `blink-cursor-colors'."
;;   (when (not (internal-show-cursor-p))
;;     (when (>= blink-cursor-count (length blink-cursor-colors))
;;       (setq blink-cursor-count 0))
;;     (set-cursor-color (nth blink-cursor-count blink-cursor-colors))
;;     (setq blink-cursor-count (+ 1 blink-cursor-count))
;;     )
;;   (internal-show-cursor nil (not (internal-show-cursor-p)))
;;   )

;; mouse support in terminal mode
(when (eq window-system nil)
  (xterm-mouse-mode t))

;;(mouse-avoidance-mode 'cat-and-mouse)

;;for mouse wheel with scroll-all-mode (across several buffers, e.g., for diff)
(defun mwheel-scroll-all-function-all (func &optional arg)
  (if (and scroll-all-mode arg)
      (save-selected-window
        (walk-windows
         (lambda (win)
           (select-window win)
           (condition-case nil
               (funcall func arg)
             (error nil)))))
    (funcall func arg)))
(defun mwheel-scroll-all-scroll-up-all (&optional arg)
  (mwheel-scroll-all-function-all 'scroll-up arg))
(defun mwheel-scroll-all-scroll-down-all (&optional arg)
  (mwheel-scroll-all-function-all 'scroll-down arg))
(setq mwheel-scroll-up-function 'mwheel-scroll-all-scroll-up-all)
(setq mwheel-scroll-down-function 'mwheel-scroll-all-scroll-down-all)

;; scroll one line at a time (less "jumpy" than defaults)
;; useful for scrolling with inline images
(setq mouse-wheel-scroll-amount '(1 ((shift) . 1))) ;; one line at a time
(setq mouse-wheel-progressive-speed t) ;; do accelerate scrolling (nil for not)
(setq mouse-wheel-follow-mouse 't) ;; scroll window under mouse
(setq scroll-step 1) ;; keyboard scroll one line at a time

;; emacs25 --daemon=foo 
;; -c: GUI
;; emacsclient -c -s ~/.emacs.d/server/foo minimanifesto.org 


;; starteserver(){
;; 	if [[ $# -eq 0 ]] ; then
;; 	d="main"
;; else
;; d=$1
;;     fi
;;     echo $d
;; 	emacs25 --daemon=$d &
;; }
;; killeserver(){
;; 	if [[ $# -eq 0 ]] ; then
;; 	d="main"
;; else
;; d=$1
;;     fi
;; 	emacsclient -e -s ~/.emacs.d/server/$d '(save-buffers-kill-emacs)'
;; }
;; starteclient(){
;; aflag=
;; dflag=
;; while getopts ":had:" name
;; do
;;     case ${name} in
;;     a    aflag=1;;
;;     d    dflag=1
;;           dval="$OPTARG";;
;;     h    printf "Usage: %s: [-a] [-d value] args\n" $0
;;           return ;;
;;     * printf "Usage: %s: [-a] [-d value] args\n" $0 ;;
;;     esac
;; done
;; if [ ! -z "$aflag" ]; then
;;     printf "Option -a specified\n"
;; fi
;; if [ ! -z "$dflag" ]; then
;;     #printf 'Option -d "%s" specified\n' "$dval"
;;     d=$dval
;; else
;; d="main"
;; fi
;; #echo $d
;; shift $(($OPTIND - 1))
;; #printf "Remaining arguments are: %s\n" "$*"
;; emacsclient -c -s ~/.emacs.d/server/$d "$*"
;; }
;; alias es=starteserver
;; alias ec=starteclient
;; alias ke=killeserver

;;avoid the message server-start in other emacs sesssion
(require 'server)
(setq server-name (format-time-string "%Y-%m-%dT%H:%M:%S")) ;;provide unique server name
(setq server-socket-dir "~/.emacs.d/server")
(unless (server-running-p) (server-start))

(global-set-key (kbd "\C-ci")
                (defhydra hydra-templates
                  (:exit t)
                  "templates"
                  ("d" insert-deft-note-template "Deft")
                  ("o" insert-template "Browse")
                  ("e" insert-ein-block-template "ein block")
                  ("q" nil "cancel" :color blue)))

(defun insert-template ()
  (interactive)
  (let ((filename (read-file-name "Enter file name:" "~/ownCloud/Templates/")))
    (insert-file-contents filename)
    (if (str= (file-name-extension filename) "org")
        (org-mode)))
  )

(defun insert-deft-note-template ()
  (interactive)
  (insert-file-contents "~/ownCloud/Templates/NotesDeft/notes.org"))


(defun insert-ein-block-template ()
  (interactive)
  (insert-file-contents "~/ownCloud/Templates/Python/ein-block.org"))

;; hydra to move around text
(global-set-key (kbd "\C-cm")
                (defhydra hydra-move
                  (:body-pre (next-line))
                  "move"
                  ("n" next-line "next line")
                  ("p" previous-line "previous line")
                  ;;("p" (lambda () (interactive) (forward-line -1))  "up")
                                        ;("f" forward-char "forward")
                                        ;("b" backward-char "backward")
                  ("a" beginning-of-line "line start")
                  ("e" move-end-of-line "line end")
                  ("g" goto-line "goto line")
                  ;;("v" scroll-up-command "up")
                  ;; Converting M-v to V here by analogy.
                  ;;("V" scroll-down-command "down")
                  ("t" (lambda () (interactive)(move-to-window-line-top-bottom 0)) "top")
                  ("b" (lambda () (interactive)(move-to-window-line-top-bottom -1)) "bottom")
                  ("m" (lambda () (interactive)(move-to-window-line-top-bottom)) "middle")
                  ("c" recenter-top-bottom "center")
                  ("q" nil "cancel" :color blue)))

;; hydra for region actions
(global-set-key (kbd "\C-cr")
                (defhydra hydra-region 
                  (:exit t) ;;exit right after
                  "region"
                  ("s" ispell-region "spell check")
                  ("u" unfill-paragraph "unfill")
                  ("c" count-words-region "count words")))

;; hydra for word actions
(global-set-key (kbd "\C-cw")
                (defhydra hydra-word 
                  (:exit t) ;;exit right after
                  "word"
                  ("s" ispell-word "spell check")
                  ("S" helm-flyspell-correct "helm spell check")
                  ("$" flyspell-correct-word-generic "ivy spell check")
                  ("z" ac-fuzzy-complete "fuzzy complete")
                  ("t" google-translate-at-point "translate")
                  ("e" lookup-word-en "lookup-en")
                  ("f" lookup-word-fr "lookup-fr")
                  ("u" upcase-region "upcase")
                  ("d" downcase-region "downcase")
                  ("c" capitalize-region "capitalize")
                  ("q" nil "cancel" :color blue)))

;; dead keys
(require 'iso-transl)

;; prefer UTF-8 encoding
;;(prefer-coding-system 'utf-8)

(when (display-graphic-p)
  (setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING)))

(prefer-coding-system 'utf-8-unix)
(set-language-environment "UTF-8")
(set-locale-environment "en_US.UTF-8")
(set-default-coding-systems 'utf-8-unix)
(set-selection-coding-system 'utf-8-unix)
(set-buffer-file-coding-system 'utf-8-unix)
(set-clipboard-coding-system 'utf-8) ; included by set-selection-coding-system
(set-keyboard-coding-system 'utf-8) ; configured by prefer-coding-system
(set-terminal-coding-system 'utf-8) ; configured by prefer-coding-system
(setq buffer-file-coding-system 'utf-8) ; utf-8-unix
(setq save-buffer-coding-system 'utf-8-unix) ; nil
(setq process-coding-system-alist
      (cons '("grep" utf-8 . utf-8) process-coding-system-alist))

;; highlight parentheses when inside
(define-advice show-paren-function (:around (fn) fix)
  "Highlight enclosing parens."
  (cond ((looking-at-p "\\s(") (funcall fn))
        (t (save-excursion
             (ignore-errors (backward-up-list))
             (funcall fn)))))

;; Show matching parentheses
(setq show-paren-delay 1)
(show-paren-mode 1)
                                        ;(setq show-paren-style 'expression) ;; or 'parenthesis (default) or 'mixed or 'expression

                                        ;(require 'paren)
                                        ;(set-face-attribute 'show-paren-match-face nil 
                                        ;:foreground nil
                                        ;:background nil
                                        ;:box nil)

                                        ;(set-face-attribute 'region nil :background "#222" :foreground "#FF0" :underline t)
;;(set-face-foreground 'show-paren-match-face '#222')

;; highlight inside ()
(setq show-paren-style 'parenthesis)
(require 'paren)
                                        ;(set-face-background 'show-paren-match (face-foreground 'default))
;;(set-face-background 'show-paren-match (face-foreground 'default))
                                        ;(set-face-background 'show-paren-match nil)
(set-face-foreground 'show-paren-match nil)
(set-face-attribute 'show-paren-match nil :weight 'extra-bold)


                                        ;(add-hook 'minibuffer-setup-hook 'turn-on-smartparens-strict-mode)
                                        ;(add-hook 'prog-mode-hook 'turn-on-smartparens-strict-mode)
                                        ;(add-hook 'markdown-mode-hook 'turn-on-smartparens-strict-mode)

;; following already in smartparens
                                        ;(setq show-paren-highlight-openparen t
                                        ;      show-paren-when-point-inside-paren t)

;; hydra
(global-set-key (kbd "\C-cp")
                (defhydra smartparens-hydra ()
                  "Smartparens"
                  ("n" sp-forward-sexp "Next")
                  ("p" sp-backward-sexp "Previous")
                  ("d" sp-down-sexp "Forward-down")
                  ("u" sp-up-sexp "Forward-up")
                  ("U" sp-backward-up-sexp "Back-Up")
                  ("D" sp-backward-down-sexp "Back-Down")
                  ("k" sp-kill-sexp "Kill" :color blue)
                  ("c" sp-copy-sexp "Copy" :color blue)
                  ("s" sp-splice-sexp "Splice" :color blue)
                  ("q" nil "Quit" :color blue)))

;; colorful parentheses
(use-package rainbow-delimiters
  :ensure t
  :config
  (add-hook 'prog-mode-hook 'rainbow-delimiters-mode))

(custom-set-faces
 '(rainbow-delimiters-depth-1-face ((t (:foreground "#0F0"))))
 '(rainbow-delimiters-depth-2-face ((t (:foreground "#FF0"))))
 '(rainbow-delimiters-depth-3-face ((t (:foreground "#FA0"))))

 '(rainbow-delimiters-depth-4-face ((t (:foreground "#0D0"))))
 '(rainbow-delimiters-depth-5-face ((t (:foreground "#DD0"))))
 '(rainbow-delimiters-depth-6-face ((t (:foreground "#D80"))))

 '(rainbow-delimiters-depth-7-face ((t (:foreground "#0A0"))))
 '(rainbow-delimiters-depth-8-face ((t (:foreground "#AA0"))))
 '(rainbow-delimiters-depth-9-face ((t (:foreground "#A50"))))

 '(rainbow-delimiters-unmatched-face ((t (:background "black"))))
 )

(global-subword-mode 1)                           ; Iterate through CamelCase words

;; word wrap
(global-visual-line-mode)

;; highlight colors
(use-package rainbow-mode
  :load-path "~/elisp/rainbow-mode.el/"
  :unless (string-prefix-p "example.com" (system-name))
  :diminish rainbow-mode
  :config
  (add-hook 'emacs-lisp-mode-hook 'rainbow-mode)
  (add-hook 'css-mode-hook 'rainbow-mode)
  (add-hook 'html-mode-hook 'rainbow-mode)
  (add-hook 'js2-mode-hook 'rainbow-mode))

;; Remove text in active region if inserting text
(delete-selection-mode 1)

;; emacs clipboard available to other apps
(setq x-select-enable-clipboard t)

;; ends sentences with single space
(setq sentence-end-double-space nil)

;;unfill
                                        ;(defun unfill-region (beg end)
                                        ;  "Unfill the region, joining text paragraphs into a single
                                        ;    logical line.  This is useful, e.g., for use with
                                        ;    `visual-line-mode'."
                                        ;  (interactive "*r")
                                        ;  (let ((fill-column (point-max)))
                                        ;    (fill-region beg end)))

(defun unfill-paragraph (&optional region)
  "Takes a multi-line paragraph and makes it into a single line of text."
  (interactive (progn (barf-if-buffer-read-only) '(t)))
  (let ((fill-column (point-max))
        ;; This would override `fill-column' if it's an integer.
        (emacs-lisp-docstring-fill-column t))
    (fill-paragraph nil region)))

;; show white spaces
(require 'whitespace)
(global-whitespace-mode 1)

(progn
  ;; Make whitespace-mode with very basic background coloring for whitespaces.
  ;; http://ergoemacs.org/emacs/whitespace-mode.html
  (setq whitespace-style (quote (face spaces tabs newline space-mark tab-mark newline-mark )))


  ;;causing issues with some tex files
                                        ; Make whitespace-mode and whitespace-newline-mode use “¶” for end of line char and “▷” for tab.
  (setq whitespace-display-mappings
        ;; all numbers are unicode codepoint in decimal. e.g. (insert-char 182 1)
        '(
          (space-mark 32 [183] [46]) ; SPACE 32 「 」, 183 MIDDLE DOT 「·」, 46 FULL STOP 「.」
          ;;newline-mark 10 [182 10]) ; LINE FEED,
          (newline-mark 10 [8628 10])
                                        ;(tab-mark 9 [9655 9] [92 9]) ; tab
          (tab-mark 9 [8680 9] [92 9]) ; tab
          ))

  )

(set-face-attribute 'whitespace-tab nil
                    :background "#222244"
                    :foreground "#FFFF00"
                    :weight 'bold)

(set-face-attribute 'whitespace-newline nil
                    :background "#222244"
                    :weight 'normal)

(setq-default
 tab-width 4                                      ; Set width for tabs
 indent-tabs-mode nil                             ; Stop using tabs to indent
 )

;; Enable syntax coloring                                           
                                        ;(setq font-lock-maximum-decoration t)
                                        ;(global-font-lock-mode t)

(setq org-src-preserve-indentation nil 
      org-edit-src-content-indentation 0)

;; spelling

;;enable flyspell
(dolist (hook '(text-mode-hook))
  (add-hook hook (lambda () (flyspell-mode 1))))
;;(add-hook 'text-mode-hook 'flyspell-mode) ;;sometimes freezes

;;spelling in comments
;;(add-hook 'prog-mode-hook 'flyspell-prog-mode)
;;see programming for list of progs
;; (dolist (mode '(emacs-lisp-mode-hook
;;                 lisp-mode-hook
;;                 python-mode-hook
;;                 php-mode-hook
;;                 c-mode-hook
;;                 cc-mode-hook
;;                 c++-mode-hook
;;                 java-mode-hook
;;                 perl-mode-hook
;;                 sh-mode-hook
;;                 fortran-mode-hook
;;                 f90-mode-hook
;;                 xml-mode-hook
;;                 latex-mode-hook
;;                 html-mode-hook
;;                 css-mode-hook
;;                 web-mode-hook
;;                 js-mode-hook
;;                 R-mode-hook))
;;   (add-hook mode '(lambda () (flyspell-prog-mode))))


(setq flyspell-issue-message-flag nil) ;; printing messages for every word (when checking the entire buffer) causes an enormous slowdown



;;spelling

;; sudo apt-get install aspell-fr hunspell

(global-set-key (kbd "<f2>") 'ispell-word)
(defun flyspell-check-next-highlighted-word ()
  "Custom function to spell check next highlighted word"
  (interactive)
  (flyspell-goto-next-error)
  (ispell-word))
(global-set-key (kbd "C-<f2>") 'flyspell-check-next-highlighted-word)
;; correct
                                        ;(global-set-key (kbd "<C-f3>") 'helm-flyspell-correct)
                                        ;(global-set-key (kbd "<C-f4>") 'flyspell-correct-word-generic)

(with-eval-after-load "ispell"
  ;; find aspell and hunspell automatically
  (cond
   ;; try hunspell at first
   ;; if hunspell does NOT exist, use aspell
   ((executable-find "hunspell")
    (setq ispell-program-name "hunspell")
    (setq ispell-dictionary "en_US")
    ;; ispell-set-spellchecker-params has to be called
    ;; before ispell-hunspell-add-multi-dic will work
    (ispell-hunspell-add-multi-dic "en_US")
    (setq ispell-local-dictionary "en_US")
    (setq ispell-local-dictionary-alist
          ;; Please note the list `("-d" "en_US")` contains ACTUAL parameters passed to hunspell
          ;; You could use `("-d" "en_US,en_US-med")` to check with multiple dictionaries
                                        ;'(("en_US" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_US,fr_FR") nil utf-8) ;;eiter do this or enable guess-language
          '(("en_US" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_US") nil utf-8)
            )))

   ((executable-find "aspell")
    (setq ispell-program-name "aspell")
    ;; Please note ispell-extra-args contains ACTUAL parameters passed to aspell
    (setq ispell-extra-args '("--sug-mode=ultra" "--lang=en_US")))))



                                        ;(ispell-check-version)




;; use hunspell 
(with-eval-after-load "ispell"
  (setq ispell-check-comments t)
  )

;; ;; Automatically detect language for Flyspell for current paragraph! Also reruns flyspell, just on the paragraph
;; (use-package guess-language  
;;   :disabled t
;;   :ensure t
;;   :defer t
;;   :init (add-hook 'text-mode-hook #'guess-language-mode)
;;   :config
;;   (setq guess-language-langcodes '((en . ("en_US" "English"))
;;                                    (fr . ("fr_FR" "French")))
;;         guess-language-languages '(en fr)
;;         guess-language-min-paragraph-length 40) ;minimal length that a paragraph needs to have before guess-language-mode starts guessing
;; ;;keep only en and fr
;; (defcustom guess-language-langcodes
;;   '(   (en . ("en"         "English"))
;;        (fr . ("francais"   "French"))
;;        )
;;   "Language codes for spell-checker and typo-mode.

;; The key is a symbol specifying the ISO 639-1 code of the
;; language.  The values is a list with two elements.  The first is
;; the name of the dictionary that should be used by the
;; spell-checker (e.g., what you would enter when setting the
;; language with `ispell-change-dictionary').  The second element is
;; the name of the language setting that should be used with
;; typo-mode.  If a language is not supported by typo-mode, that
;; value is nil."
;;   :type '(alist :key-type symbol :value-type list))

;;   :diminish guess-language-mode)

                                        ;(require 'guess-language)
;; Optionally:
                                        ;(setq guess-language-languages '(en fr))
                                        ;(setq guess-language-min-paragraph-length 35)
                                        ;(guess-language-mode)



                                        ;(custom-set-faces
                                        ;'(flyspell-incorrect-face ((((class color)) (:foreground "black" :size "13" :bold t :underline t)))))
                                        ;(use-package flyspell
                                        ;  :diminish (flyspell-mode . "spell")
                                        ;  :config
                                        ;  (set-face-attribute 'flyspell-incorrect nil :background "selectedKnobColor" :underline '(:color "black") :weight 'bold)
                                        ;  )

                                        ;(ispell-change-dictionary "francais")
                                        ;(ispell-change-dictionary "en_US") 


(custom-theme-set-faces
 'user
                                        ;'(flyspell-duplicate ((t (:weight bold :overline "#FFFF00" :underline (:color "#ffff00" :style line)))))
                                        ;'(flyspell-incorrect ((t (:weight normal :overline "#AA0000" :underline (:color "#AA0000" :style line)))))
                                        ;'(flyspell-duplicate ((t (:overline "#FFFF00" :underline nil :background "#400")))) ;:weight bold 
                                        ;'(flyspell-incorrect ((t (:overline "#AA0000" :underline nil :background "#400")))) ;:weight normal
 '(flyspell-duplicate ((t (:underline nil :background "#400")))) ;:weight bold 
 '(flyspell-incorrect ((t (:underline nil :background "#440")))) ;:weight normal

 )

;;install from package manager and check that libtiff from conda is not first (remove or rename)
;; install libtiff and libpoppler from apt-get too

;;https://github.com/pinguim06/pdf-tools-org
;;http://tech.memoryimprintstudio.com/pdf-annotation-related-tools/

;;if you want to auto export the annotations after saving a pdf, also add this:
                                        ;(add-hook 'after-save-hook
                                        ;          (lambda ()
                                        ;            (when (eq major-mode 'pdf-view-mode) (pdf-tools-org-export-to-org))))

;; for annotations
(defun save-buffer-no-args ()
  "Save buffer ignoring arguments"
  (save-buffer))

;; hydra for PDF actions (type ? in PDF)
(defhydra hydra-pdf ()
  "pdf"
  ("<" pdf-view-first-page "first page")
  (">" pdf-view-last-page "last page")
  ("+" pdf-view-enlarge "+")
  ("-" pdf-view-shrink "-")
  ("g" pdf-view-goto-page "g")
  ("t" pdf-annot-add-text-annotation "text")
  ("h" pdf-annot-add-highlight-markup-annotation "highlight")
  ("/" pdf-annot-add-strikeout-markup-annotation "strikeout")
  ("u" pdf-annot-add-underline-markup-annotation "underline")
  ("~" pdf-annot-add-squiggly-annotation "squiggly")
  ("d" pdf-annot-delete "delete")
  ("p" pdf-tools-org-export-to-org "->org")
  ("o" pdf-outline "outline")
  ("s" pdf-occur "occur")
  ("n" org-noter "org-noter")
  ("S" org-noter-create-skeleton "org-noter skeleton")
  ("q" nil "cancel" :color blue))

                                        ;(use-package pdf-tools
                                        ;  :ensure t
                                        ;  :mode ("\\.pdf\\'" . pdf-tools-install)
                                        ;  ;;:bind ("C-c C-g" . pdf-sync-forward-search)
                                        ;  :defer t
                                        ;  :config
                                        ;  (setq mouse-wheel-follow-mouse t)
                                        ;  (setq pdf-view-resize-factor 1.10)
                                        ;  (pdf-tools-enable-minor-modes))

;; main
(use-package pdf-tools
  :defer t
  :init
  (add-to-list 'load-path "~/.emacs.d/pdf-tools-org-vian")
                                        ;(add-to-list 'load-path "~/.emacs.d/pdf-tools-org")
  (require 'pdf-tools-org)
  :bind (:map pdf-view-mode-map ("C-<f1>" . show-pdf-tools-help)
              ("?"  . hydra-pdf/body)
                                        ;("<f2>"  . pdf-annot-add-text-annotation)
                                        ;("<f3>" . pdf-annot-add-highlight-markup-annotation)
                                        ;("<f4>" . pdf-annot-add-strikeout-markup-annotation)
                                        ;("<f5>" . pdf-annot-add-underline-markup-annotation)
                                        ;("<f6>" . pdf-annot-add-squiggly-markup-annotation)
              ("<f10>" . pdf-tools-org-export-to-org)
              ("<f9>" . pdf-annot-delete)
              ("o" . pdf-outline)
              ("s" . pdf-occur)
              ("C-s" . isearch-forward) ;; use isearch instead of swiper
              ("/" . pdf-annot-add-strikeout-markup-annotation)
              ("h" . pdf-annot-add-highlight-markup-annotation)
              ("u" . pdf-annot-add-underline-markup-annotation)
              ("~" . pdf-annot-add-squiggly-markup-annotation)
              ("t" . pdf-annot-add-text-annotation)
              ("d" . pdf-annot-delete)
              ("n" . org-noter)
              ("S" . org-noter-create-skeleton)
              )
  :config

  ;; initialise
  (pdf-tools-install)

  ;; http://pragmaticemacs.com/emacs/even-more-pdf-tools-tweaks/
  ;; open pdfs scaled to fit page
  (setq-default pdf-view-display-size 'fit-page)



  ;; automatically annotate highlights
  (setq pdf-annot-activate-created-annotations t)

  ;; auto-revert
  ;;(add-hook 'pdf-view-mode-hook 'pdf-outline)

                                        ;(defun pdf-outline-tmp ()
                                        ;(pdf-outline)
                                        ;(let ((bn (file-name-nondirectory pdf-outline-pdf-document)))
                                        ;(next-multiframe-window)
                                        ;(switch-to-buffer bn)
                                        ;)
                                        ;)

                                        ;(add-hook 'pdf-tools-enabled-hook 'pdf-outline-tmp)
  (add-hook 'pdf-view-mode-hook (lambda () (auto-revert-mode 1)))
  (add-hook 'pdf-tools-enabled-hook (lambda () (auto-revert-mode 1)))
  ;;(setq auto-revert-interval 0.5) ?

  ;; use normal isearch
  ;;(define-key pdf-view-mode-map (kbd "C-s") 'isearch-forward)

  ;; more fine-grained zooming
  (setq pdf-view-resize-factor 1.1)
  ;; wrapper for save-buffer ignoring arguments

  ;; http://pragmaticemacs.com/emacs/even-more-pdf-tools-tweaks/

  ;;display page number in outline
  (setq pdf-outline-display-labels 1)

  ;; wait until map is available
  (with-eval-after-load "pdf-annot"
    ;;(define-key pdf-annot-edit-contents-minor-mode-map (kbd "<return>") 'pdf-annot-edit-contents-commit)
    (define-key pdf-annot-edit-contents-minor-mode-map (kbd "<S-return>") 'newline)
    ;; save after adding comment
    (advice-add 'pdf-annot-edit-contents-commit :after 'save-buffer-no-args)
    )

  ;;colors
                                        ;(setq pdf-annot-default-text-annotation-properties
                                        ; '((color . "deep sky blue")))
                                        ;(setq pdf-annot-default-markup-annotation-properties
                                        ;      '((color . "orange")))

  (setq pdf-annot-default-annotation-properties
        '((t
           (label . ""))
          (text
           (color . "deep sky blue")
           (icon . "Insert"))
          (highlight
           (color . "yellow"))
          (underline
           (color . "red"))
          (squiggly
           (color . "red"))
          (strike-out
           (color . "red"))))

  ;; midnite mode hook
  ;;(add-hook 'pdf-view-mode-hook (lambda ()
  ;;                                 (pdf-view-midnight-minor-mode))) ; automatically turns on midnight-mode for pdfs

  (setq pdf-view-midnight-colors '("#ff9900" . "#0a0a12" )) ; set the amber profile as default (see below)

  ;; some filters
  (defun pdf-no-filter ()
    "View pdf without colour filter."
    (interactive)
    (pdf-view-midnight-minor-mode -1)
    )
  ;; change midnite mode colours functions
  (defun pdf-midnite-original ()
    "Set pdf-view-midnight-colors to original colours."
    (interactive)
    (setq pdf-view-midnight-colors '("#FFFFFF" . "#151515" )) ; original values
    (pdf-view-midnight-minor-mode)
    )
  (defun pdf-midnite-amber ()
    "Set pdf-view-midnight-colors to amber on dark slate blue."
    (interactive)
    (setq pdf-view-midnight-colors '("#101010" . "#FFFFEE" )) ; amber
    (pdf-view-midnight-minor-mode)
    )
  (defun pdf-midnite-white ()
    "Set pdf-view-midnight-colors to white on black."
    (interactive)
    (setq pdf-view-midnight-colors '("#000000" . "#EEEEEE" )) ; white
    (pdf-view-midnight-minor-mode)
    )
  (defun pdf-midnite-colour-schemes ()
    "Midnight mode colour schemes bound to keys"
    (local-set-key (kbd "!") (quote pdf-no-filter))
    (local-set-key (kbd "@") (quote pdf-midnite-amber)) 
    (local-set-key (kbd "#") (quote pdf-midnite-white))
    (local-set-key (kbd "$") (quote pdf-midnite-original))
    )  
  (add-hook 'pdf-view-mode-hook 'pdf-midnite-colour-schemes)


  ;; help
  (defun show-pdf-tools-help ()
    (interactive)
    (message-box "
PDF-TOOLS
---------
?: hydra
o: outline
t: text annotation
h: highlight
/: strikeout
u: underline
~: squiggly
d: delete annotation
s: occur
n: org-noter (i: insert, M-i: precise)
S: org-noter-create-skeleton
<f10>: export annotations to ORG file
"))

  )

(require 'google-translate)
(require 'google-translate-default-ui)

(global-set-key "\C-cq" 'google-translate-query-translate)

                                        ;or
                                        ;(require 'google-translate)
                                        ;(require 'google-translate-smooth-ui)
                                        ;(global-set-key "\C-ct" 'google-translate-smooth-translate)

(defun lookup-word-fr ()
  "Look up the word under cursor in Wikipedia.
If there is a text selection (a phrase), use that.

This command switches to browser."
  (interactive)
  (let (word)
    (setq word
          (if (use-region-p)
              (buffer-substring-no-properties (region-beginning) (region-end))
            (current-word)))
    (setq word (replace-regexp-in-string " " "_" word))
    (browse-url (concat "http://www.cnrtl.fr/definition/" word))
    ;;(browse-url (concat "https://fr.wiktionary.org/wiki/" word))
    ;; (eww myUrl) ; emacs's own browser
    ))

(defun lookup-word-en ()
  "Look up the word under cursor in Wikipedia.
If there is a text selection (a phrase), use that.

This command switches to browser."
  (interactive)
  (let (word)
    (setq word
          (if (use-region-p)
              (buffer-substring-no-properties (region-beginning) (region-end))
            (current-word)))
    (setq word (replace-regexp-in-string " " "_" word))
    (browse-url (concat "https://en.wiktionary.org/wiki/" word))
    ;; (eww myUrl) ; emacs's own browser
    ))

;; Usage: emacs -diff file1 file2

;; ediff
(require 'ediff)
;; don't start another frame
;; this is done by default in preluse
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
;; put windows side by side
(setq ediff-split-window-function (quote split-window-horizontally))
;;revert windows on exit - needs winner mode
(winner-mode)
(add-hook 'ediff-after-quit-hook-internal 'winner-undo)

(setq ediff-diff-options "-w")

(defun command-line-diff (switch)
  (let ((file1 (pop command-line-args-left))
        (file2 (pop command-line-args-left)))
    (ediff file1 file2)

    ;; if org files -> uncollapse!
    (dolist (buffer (buffer-list t))
      (set-buffer buffer)
      (if (string-match ".org" (buffer-name buffer))
          (outline-show-all)))

    ))
(add-to-list 'command-switch-alist '("diff" . command-line-diff))   ;; (add-to-list 'command-switch-alist '("-diff" . command-line-diff))

                                        ;keep highlights until next C-S/R 
(setq lazy-highlight-cleanup nil)
;;(setq lazy-highlight-max-at-a-time nil)
;;(setq lazy-highlight-initial-delay 0)

;; hydra for search actions
(global-set-key (kbd "\C-cs")
                (defhydra hydra-search
                  (:exit t) ;;exit right after
                  "search"
                  ("s" isearch "case-insensitive")
                  ("S" isearch-case-sensitive "case-sensitive")
                  ("o" occur "occurences")))

;; case-sensitive search
(defun isearch-case-sensitive ()
  (interactive)
  (let* ((case-fold-search t))
    (isearch-forward))
  )

;; backspace behavior
(define-key isearch-mode-map [remap isearch-delete-char] 'isearch-del-char)

;; face for other matches when main one is highlighted
(custom-set-faces
 `(lazy-highlight ((t (:foreground "white" :background "SteelBlue")))))

;; isearch face
(custom-set-faces
 `(isearch ((t (:foreground "black" :background "yellow")))))


;; better replace
(use-package anzu
  :bind
  ([remap query-replace] . anzu-query-replace-regexp)
  :hook
  (after-init . global-anzu-mode)
  :custom
  (anzu-cons-mode-line-p nil))

                                        ; Merge system's and Emacs' clipboard
(setq-default select-enable-clipboard t)

                                        ;AUTOMATICALLY COPY TEXT SELECTED WITH THE MOUSE
(setq mouse-drag-copy-region t)

;; paste (yank) from kill-ring by repeating C-y instead of C-y then M-y
(defun xah-paste-or-paste-previous ()
  "Paste. When called repeatedly, paste previous.
This command calls `yank', and if repeated, call `yank-pop'.

When `universal-argument' is called first with a number arg, paste that many times.

URL `http://ergoemacs.org/emacs/emacs_paste_or_paste_previous.html'
Version 2017-07-25"
  (interactive)
  (progn
    (when (and delete-selection-mode (region-active-p))
      (delete-region (region-beginning) (region-end)))
    (if current-prefix-arg
        (progn
          (dotimes ($i (prefix-numeric-value current-prefix-arg))
            (yank)))
      (if (eq real-last-command this-command)
          (yank-pop 1)
        (yank)))))
(global-set-key (kbd "C-y") 'xah-paste-or-paste-previous)




                                        ;(defadvice yank (before yank-if-overwrite)
                                        ;  (if (bound-and-true-p overwrite-mode)
                                        ;      (delete-char (length (current-kill 0))))
                                        ;  )
                                        ;(ad-activate 'yank)

(defun yank-unfill ()
  (interactive)     
                                        ;(insert (replace-regexp-in-string "\n" " " (car kill-ring-yank-pointer)));; eventually replace with insert-for-yank-1
  (setq tmp (replace-regexp-in-string "\n" " " (current-kill 0)))
  (setq tmp (replace-regexp-in-string "- " "" tmp))
  (setq tmp (replace-regexp-in-string "- " "" tmp))
  (insert (concat "\"" tmp "\""));; eventually replace with insert-for-yank-1
  )
(global-set-key (kbd "C-S-y") 'yank-unfill) ; Yank with the Shift key to swap instead of paste.



                                        ;replace actual yank
                                        ;(defadvice yank (before yank)
                                        ;  (kill-new (replace-regexp-in-string "\n" " " (car kill-ring-yank-pointer)))
                                        ;)
                                        ;(ad-activate 'yank)


;; (defun clipboard-swap () "Swaps the clipboard contents with the highlighted region"
;;     (interactive)
;;     (if (use-region-p)
;;         (progn
;;             (setq
;;                 reg-beg (region-beginning)
;;                 reg-end (region-end))
;;             (deactivate-mark)
;;             (goto-char reg-end)
;;             (clipboard-yank)
;;             (clipboard-kill-region reg-beg reg-end))
;;         (clipboard-yank)))

;; (global-set-key (kbd "C-S-Y") 'clipboard-swap) ; Yank with the Shift key to swap instead of paste.

;; ln -s ~/ownCloud/org/.elfeed ~/.elfeed

;; hydra for elfeed actions
                                        ;(defhydra mz/hydra-elfeed ()
                                        ;"filter"
                                        ;("c" (elfeed-search-set-filter "@6-months-ago +cs") "cs")
                                        ;("e" (elfeed-search-set-filter "@6-months-ago +emacs") "emacs")
                                        ;("d" (elfeed-search-set-filter "@6-months-ago +education") "education")
                                        ;("*" (elfeed-search-set-filter "@6-months-ago +star") "Starred")
                                        ;("M" elfeed-toggle-star "Mark")
                                        ;("A" (elfeed-search-set-filter "@6-months-ago") "All")
                                        ;("T" (elfeed-search-set-filter "@1-day-ago") "Today")
                                        ;("Q" bjm/elfeed-save-db-and-bury "Quit Elfeed" :color blue)
                                        ;("q" nil "quit" :color blue)
                                        ;)

;; load elfeed using db
(defun elfeed-load ()
  "Wrapper to save the elfeed db to disk before burying buffer"
  (interactive)
  (require 'elfeed)
  (elfeed-load-db-and-open))
;;(global-set-key (read-kbd-macro "<C-f6>") 'elfeed-load)

;; main
(use-package elfeed
  :ensure t
  :defer t
  :commands elfeed-load
  :bind ((:map elfeed-search-mode-map
               ("C-<f1>" . show-elfeed-help)
               ("?" . elfeed-update2)
               ("U" . elfeed-show-unread)
               ("R" . elfeed-show-read)
               ("q" . elfeed-save-db-and-bury))
         (:map elfeed-show-mode-map
               ("C-<f1>" . show-elfeed-help))
         )
  :init 

  (defun elfeed-update2 ()
    "Wrapper to save the elfeed db to disk before burying buffer"
    (interactive)
    (elfeed-update)
    (elfeed-db-save))

  (defun elfeed-save-db-and-bury ()
    "Wrapper to save the elfeed db to disk before burying buffer"
    (interactive)
    (elfeed-db-save)
    (quit-window))

  ;;functions to support syncing .elfeed between machines
  ;;makes sure elfeed reads index from disk before launching
  (defun elfeed-load-db-and-open ()
    "Wrapper to load the elfeed db from disk before opening"
    (interactive)
    (elfeed-db-load)
    (elfeed)
    (elfeed-search-update--force))

  ;; unread
  (defun elfeed-show-unread ()
    "Wrapper to save the elfeed db to disk before burying buffer"
    (interactive)
    (elfeed-search-set-filter "@6-months-ago +unread")
    )

  ;; read
  (defun elfeed-show-read ()
    "Wrapper to save the elfeed db to disk before burying buffer"
    (interactive)
    (elfeed-search-set-filter "@6-months-ago -unread")
    )
  :config

  (setq elfeed-search-title-min-width 60)
  (setq elfeed-search-title-max-width 100)
  (setq elfeed-search-trailing-min-width 0)

  (defun elfeed-search-format-date (date)
    (format-time-string "%m-%d" (seconds-to-time date)))

  (add-hook 'elfeed-show-mode-hook (text-scale-set 1.4))

                                        ;now done in elfeed-org


  ;;shortcut functions
  (setq-default elfeed-search-filter "@6-months-ago +unread")

;;; browse article in gui browser instead of eww
                                        ;(defun elfeed-show-visit-gui ()
                                        ;  "Wrapper for elfeed-show-visit to use gui browser instead of eww"
                                        ;  (interactive)
                                        ;  (let ((browse-url-generic-program "xdg-open"))
                                        ;    (elfeed-show-visit t)))

                                        ;(define-key elfeed-show-mode-map (kbd "G") 'elfeed-show-visit-gui)
  (define-key elfeed-show-mode-map (kbd "g") 'elfeed-show-visit)

  (defun show-elfeed-help ()
    (interactive)
    (message-box "
Elfeed
------

?: update
s: search
r/u: read/unread
R/U: show read/unread
g: visit URL
"))
  )

;; Load elfeed-org
(require 'elfeed-org)

;; Initialize elfeed-org
;; This hooks up elfeed-org to read the configuration when elfeed
;; is started with =M-x elfeed=
(elfeed-org)

;; Optionally specify a number of files containing elfeed
;; configuration. If not set then the location below is used.
;; Note: The customize interface is also supported.
(setq rmh-elfeed-org-files (list "~/ownCloud/org/elfeed.org"))

;; org layout
(defun org-layout-work ()
  (interactive)
  ;;(delete-other-windows)
  (deft) 
  (cfw)

  ;(select-frame (make-frame))
  ;(delete-other-windows)
  ;(find-file "~/ownCloud/org/workflow.org")

  (select-frame (make-frame))
  (delete-other-windows)
  ;(split-window-horizontally)
  ;(org-agenda nil "P")
  ;(other-window 1)
  (org-agenda nil "A")

  (select-frame (make-frame))
  (delete-other-windows)
  (mu4e-elfeed)
  ;(select-window (mu4e)) ;;mu4e takes a long time to load...
  )

;; org layout
(defun org-layout-cal ()
  (interactive)
  ;;(delete-other-windows)
  (select-frame (make-frame))
  (delete-other-windows)
  (split-window-horizontally)
  (find-file "~/ownCloud/org/workflow.org")
  (other-window 1)
  (deft)
  (balance-windows) 
  )

;; org layout
(defun org-layout1 ()
  (interactive)
  ;;(delete-other-windows)
  (select-frame (make-frame))
  (delete-other-windows)
  (org-agenda nil "R")
  (split-window-horizontally)
  (find-file "~/ownCloud/org/workflow.org")
  )


;; org layout
(defun org-layout5 ()
  (interactive)
  ;;(delete-other-windows)
  (select-frame (make-frame))
  (delete-other-windows)
  (split-window-right)
  (split-window-right)
  (split-window-below)
  (balance-windows) 

  (other-window 4)
  (mu4e)
  (other-window 1)
  (elfeed-load)
  (other-window 1)
  (find-file "~/ownCloud/org/workflow.org")
  (other-window 1)
  (org-agenda nil "R")

  )

;; org layout
(defun org-layout6 ()
  (interactive)
  ;;(delete-other-windows)
  (select-frame (make-frame))
  (delete-other-windows)
  (split-window-right)
  (split-window-right)
  (split-window-below)
  (other-window 2)
  (split-window-below)
  (balance-windows) 

  (other-window 3)
  (mu4e)
  (other-window 1)
  (elfeed-load)
  (other-window 1)
  (find-file "~/ownCloud/org/workflow.org")
  (other-window 1)
  (org-agenda nil "P")
  (other-window 1)
  (org-agenda nil "A")

  )


;; org/pdf layout
(defun orgpdf-layout ()
  (interactive)
  (let ((nwin (length (cl-delete-duplicates (mapcar #'window-buffer (window-list))))))
    (org-latex-export-to-pdf)
    (if (= nwin 1)
        (progn (delete-other-windows)
               (split-window-right)
               (other-window 1)
               (find-file (replace-regexp-in-string ".org" ".pdf" buffer-file-name))))
    ))

;; Use org mode
(require 'org)
(add-to-list 'auto-mode-alist '("\\.\\(org\\|org_archive\\|txt\\)$" . org-mode))


;; specific shortcuts in org mode
(progn
  ;; modify org keys
  (require 'org )
  (define-key org-mode-map (kbd "<C-f1>") 'show-org-help)
  ;;(define-key org-mode-map (kbd "<f2>") 'org-agenda-show-agenda-and-todo)
  ;;(define-key org-mode-map (kbd "<f2>") 'org-agenda-show-agenda-and-todo-and-exportimport)
  (define-key org-mode-map (kbd "<f3>") 'exportimportics)
  (define-key org-mode-map (kbd "<f4>") 'org-todo)
  (define-key org-mode-map (kbd "<f5>") 'update-category)
  (define-key org-mode-map (kbd "<f6>") 'update-url)
  (define-key org-mode-map (kbd "C-c <f6>") 'goto-url)
                                        ;(define-key org-mode-map (kbd "C-c <f7>") 'goto-url-gui)
  (define-key org-mode-map (kbd "<f7>") 'update-location)
  (define-key org-mode-map (kbd "C-c <f10>") 'my-open-calendar)
  (define-key org-mode-map (kbd "<f9>") 'org-archive-subtree-default)
  (define-key org-mode-map (kbd "<C-S-mouse-1>") 'open-new-frame)
  (define-key org-mode-map (kbd "<C-return>") nil)
  (define-key org-mode-map (kbd "<C-S-down>") nil)
  (define-key org-mode-map (kbd "<C-S-up>") nil)
  (define-key org-mode-map (kbd "<M-S-up>") nil)
  (define-key org-mode-map (kbd "<M-S-down>") nil)
  )

;; Always start indented
(setq org-startup-indented t)


;; tag columns for table view (?)
(setq org-tags-column 20)

;; window wrap
(setq org-startup-truncated nil) 

;; category property
(defun update-category (cat)
  "Update entry single category via M-x update-category."
  (interactive "sInput category: ")
  (message "Setting category to %s" cat)
  (org-set-property "CATEGORY" cat))

;; url property
(defun update-url (url)
  "Update entry single category via M-x update-category."
  (interactive "sInput url : ")
  (if (not (string-match (regexp-quote "http") url))
      (setq url (concat "http://" url)))
  (org-set-property "URL" url))

(defun goto-url ()
  (interactive)
  (setq url (org-link-unescape (format "%S" (org-entry-get nil "URL"))))
  ;;(message-box url)
  ;;(org-open-at-point url)
  (setq urls (delete "" (split-string url))) ;;delete removes extra spaces
  (org-open-at-point urls)
  )
;;%S: Replace the specification with the printed representation of the object, made with quoting (that is, using prin1—see Output Functions). 

(defun open-new-frame ()
  "Jump to bookmark in another frame. See `bookmark-jump' for more."
  (interactive)
  (let ((org-link-frame-setup (cons (cons 'file 'find-file-other-frame) org-link-frame-setup)))
    (org-open-at-point))
  )

;; margin when exporting in latex
(setq org-latex-packages-alist '(("margin=1.5cm" "geometry" nil)))

(require 'org-bullets)
;; make available "org-bullet-face" such that I can control the font size individually
;;(setq org-bullets-face-name (quote org-bullet-face))
(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
;;(setq org-bullets-bullet-list '("○" "☉" "◎" "◉" "○" "◌" "◎" "●" "◦" "◯" "⚪" "⚫" "⚬" "❍" "￮" "⊙" "⊚" "⊛" "∙" "∘"))

;;Display the current Org header in the header-line.
(use-package org-sticky-header
  :custom
  (org-sticky-header-full-path 'full)
  (org-sticky-header-outline-path-separator " / ")
  :config
  (setq-default
   org-sticky-header-header-line-format
   '(:eval (setq org-sticky-header-stickyline (concat " " (org-sticky-header--fetch-stickyline))))))
(add-hook 'org-mode-hook (lambda () (org-sticky-header-mode 1)))

;; To never insert blank lines when inserting new headers
(setf org-blank-before-new-entry '((heading . nil) (plain-list-item . nil)))

;; replace C-enter shortcut to add subheading on top (alt/ret: add heading)
                                        ;(define-key org-mode-map (kbd "<C-return>") 'org-insert-subheading)

;; level colors
                                        ;(custom-theme-set-faces 'user
                                        ;                        `(org-level-1 ((t (:background "#303030")))))

;;The following setting hides blank lines between headings which keeps folded view nice and compact. 
(setq org-cycle-separator-lines 0)

                                        ;(setq org-fontify-whole-heading-line t)

;;Change the face of a headline if it is marked DONE. Normally, only the TODO/DONE keyword indicates the state of a headline. When this is non-nil, the headline after the keyword is set to the org-headline-done as an additional indication.
                                        ;(setq org-fontify-done-headline t)



                                        ;Add a special face to #+begin_quote and #+begin_verse block.
                                        ;(setq org-fontify-quote-and-verse-blocks t)

;;Show tags directly after headings (not on the right), which plays nicer with line-wrapping.
(setq org-tags-column 0)

;;A commonly used environment for source code is lstlisting, provided by the LaTeX package listings. To get Org-mode to use it, add it to org-latex-packages-alist and set the variable org-latex-listings to t

                                        ;(add-to-list 'org-latex-packages-alist '("" "listings" nil))
                                        ;(setq org-latex-listings t)

;; to then get listings to wrap, the breaklines=true option needs to be supplied to listings. Org-mode can do this:

(add-to-list 'org-latex-packages-alist '("" "listings" nil))
(setq org-latex-listings t)
(setq org-latex-listings-options '(("breaklines" "true")
                                   ("showstringspaces" "false")
                                   ("numbersep" "0")
                                   ("resetmargins" "true")
                                        ;("xleftmargin" "5pt")
                                        ;("xrightmargin" "5pt")
                                        ;("aboveskip" "\\bigskipamount")
                                        ;("belowskip" "\\bigskipamount")
                                   ("columns" "fullflexible")
                                   ("basicstyle" "\\small\\listingsfont")
                                        ;("literate" "{0}{0}{1}%
                                        ;{1}{1}{1}%
                                        ;{2}{2}{1}%
                                        ;{3}{3}{1}%
                                        ;{4}{4}{1}%
                                        ;{5}{5}{1}%
                                        ;{6}{6}{1}%
                                        ;{7}{7}{1}%
                                        ;{8}{8}{1}%
                                        ;{9}{9}{1}%
                                        ;")
                                   ))

(setq org-export-with-sub-superscripts "{}")

;;store org-mode links to messages
(add-to-list 'load-path "~/.emacs.d/mu/mu4e")
(require 'org-mu4e)

;;store link to message if in header view, not to header query. When you are in Headers view, M-x org-store-link links to the query if org-mu4e-link-query-in-headers-mode is non-nil, and to the particular message otherwise (which is the default).
(setq org-mu4e-link-query-in-headers-mode nil)

;; templates
(setq org-capture-templates
      '(
        ("r" "Todo-mail" entry (file+headline "~/ownCloud/org/notes/workflow.org" "Captured emails")
         "\n\n* TODO %:subject (from %:fromname) %?\nSCHEDULED: %(org-insert-time-stamp (org-read-date nil t \"+0d\"))\n%a\n")

        ;;("b" "Bookmark URL" entry (file+headline "~/ownCloud/org/notes/bookmarks.org" "Captured")
        ;; "\n\n* %?\n:PROPERTIES:\n:CREATED: %U\n:URL: http://\n:END:\n\n")

        ("B" "Bookmark clipboard URL" entry (file+headline "~/ownCloud/org/notes/bookmarks.org" "Captured")
         "\n\n* %?\n:PROPERTIES:\n:CREATED: %U\n:URL: %x\n:END:\n" :empty-lines 1)

        ("t" "To-do" entry (file+headline "~/ownCloud/org/notes/workflow.org" "Captured to-dos")
         "* TODO %?\n:PROPERTIES:\n:CREATED: %U\n:END:\nSCHEDULED: \nDEADLINE: \n" :empty-lines 1 :prepend t)

        ("T" "To-do clipboard" entry (file+headline "~/ownCloud/org/notes/workflow.org" "Captured to-dos")
         "* TODO %x\n:PROPERTIES:\n:CREATED: %U\n:END:\nSCHEDULED: \nDEADLINE: \n %?" :empty-lines 1 :prepend t)

        ("e" "Event" entry (file+headline "~/ownCloud/org/notes/events.org" "Capture events")
         "* %? %t--%t\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :empty-lines 1 :prepend t)

        ("E" "Event clipboard" entry (file+headline "~/ownCloud/org/notes/events.org" "Captured events")
         "* %x %t--%t\n:PROPERTIES:\n:CREATED: %U\n:END:\n" :empty-lines 1 :prepend t)

))
;; https://orgmode.org/manual/Template-expansion.html
;;the extra %a adds a link to the file you are visiting when you invoke the capture template. 
;;;The beauty of this is that hitting C-c c t now generates a todo item that contains a link to the email you are currently viewing. So you have zero friction in creating a todo item to e.g. reply to an email by a certain deadline, and you can happily archive that email knowing that clicking the link in the todo item will take you directly back to it. 

;; function to capture a bookmark
(defun org-capture-bookmark ()
  (interactive)
  "Capture a bookmark item"
  (org-capture nil "b"))

;; function to capture a mail todo
(defun org-capture-todomail ()
  (interactive)
  "Capture a todo-mail item"
  (org-capture nil "r"))

;; bind
(define-key global-map "\C-cc" 'org-capture)
;;(define-key global-map "\C-cb" 'org-capture-bookmark)

                                        ;(define-key mu4e-headers-mode-map (kbd "C-c c") 'org-mu4e-store-and-capture)
                                        ;(define-key mu4e-view-mode-map    (kbd "C-c c") 'org-mu4e-store-and-capture)

;; for wrap in org-columns
(defun wrap-fn () 
  (interactive) 
  (org-columns) 
  (setq truncate-lines nil word-wrap t)) 

(define-key (current-global-map) [remap org-columns] 'wrap-fn)

;; Shortcuts for showing bookmarks
(defun show-bookmarks ()
  (interactive)
  (find-file "~/ownCloud/org/notes/bookmarks.org"))
                                        ;(global-set-key "\C-cb" 'show-bookmarks)

(use-package org-noter
  :defer t
  :after org
  :ensure t
  :config (setq org-noter-default-notes-file-names '("notes.org")
                org-noter-notes-search-path '("~/org/Research-Notes")
                org-noter-separate-notes-from-heading t))

(global-set-key (kbd "\C-cD") 'deft)

(global-set-key (kbd "\C-cd") 'deft-split)

(defun deft-split ()
  (interactive)
  (split-window-horizontally)
  (next-multiframe-window)
  (deft)
  )


(use-package deft
  :defer t
  :bind (:map deft-mode-map ("C-<f1>" . show-deft-help))
  :commands (deft)
  :config 

                                        ;(setq deft-extensions '("org" "txt" "tex"))
  (setq deft-text-mode 'org-mode)
  (setq deft-auto-save-interval 0) ;; don't automatically save, do it manually
  (setq deft-directory "~/ownCloud/org/notes/")
  (setq deft-recursive t)
                                        ;(setq deft-use-filename-as-title t) ;; rather than first line of file
  (setq deft-default-extension "org")
  (setq deft-extensions '("org" "txt" "tex"))

  (defun show-deft-help ()
    (interactive)
    (message-box "
  deft-bibtex
  -----------

  C-c C-n: new file
  C-c C-r: rename
  C-c C-d: delete
  C-c C-i: insert template
  "))
  )


                                        ;(defhydra hydra-deft 
                                        ;(:exit t) ;;exit right after
                                        ;   "deft"
                                        ;   ("n" deft-new-file "New file")
                                        ;   ("d" deft-delete-file "Delete file")
                                        ;   ("r" deft-rename-file "Rename")
                                        ;   ("q" nil "cancel" :color blue))

;; replace find-files --> now using sidebar
;(global-set-key (kbd "C-x C-f") 'helm-find-files) 

;; enables yanking file names 
(defun insert-file-path (file &optional relativep)
  "Read file name and insert it at point.
With a prefix argument, insert only the non-directory part."
  (interactive "fFile: \nP")
  (when relativep (setq file  (file-name-nondirectory file)))
  (insert (file-truename file)))


(defun insert-file-name (file &optional relativep)
  "Read file name and insert it at point.
With a prefix argument, insert only the non-directory part."
  (interactive "fFile: \nP")
  (when relativep (setq file  (file-name-nondirectory file)))
  (insert (file-name-nondirectory file)))


(defun insert-file-directory (file &optional relativep)
  "Read file name and insert it at point.
With a prefix argument, insert only the non-directory part."
  (interactive "fFile: \nP")
  (when relativep (setq file  (file-name-nondirectory file)))
  (insert (file-name-as-directory file)))

;; hydra for current opened file actions
(global-set-key (kbd "\C-cf")
                (defhydra hydra-file 
                  (:exit t) ;;exit right after
                  "file"
                  ("yf" insert-file-name "Yank file name")
                  ("yd" insert-file-directory "Yank file directory")
                  ("yp" insert-file-path "Yank file path")
                  ("s" get-filesize "file size")
                  ("c" copy-file-name-to-clipboard "copy filename to clipboard")))

;; copy filename to clipboard
(defun copy-file-name-to-clipboard ()
  "Copy the current buffer file name to the clipboard."
  (interactive)
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (buffer-file-name))))
    (when filename
      (kill-new filename)
      (message "Copied buffer file name '%s' to the clipboard." filename))))

;; file size
(defun file-size-human-readable (file-size &optional flavor)
  "Produce a string showing FILE-SIZE in human-readable form.

Optional second argument FLAVOR controls the units and the display format:

 If FLAVOR is nil or omitted, each kilobyte is 1024 bytes and the produced
    suffixes are \"k\", \"M\", \"G\", \"T\", etc.
 If FLAVOR is `si', each kilobyte is 1000 bytes and the produced suffixes
    are \"k\", \"M\", \"G\", \"T\", etc.
 If FLAVOR is `iec', each kilobyte is 1024 bytes and the produced suffixes
    are \"KiB\", \"MiB\", \"GiB\", \"TiB\", etc."
  (let ((power (if (or (null flavor) (eq flavor 'iec))
                   1024.0
                 1000.0))
        (post-fixes
         ;; none, kilo, mega, giga, tera, peta, exa, zetta, yotta
         (list "" "k" "M" "G" "T" "P" "E" "Z" "Y")))
    (while (and (>= file-size power) (cdr post-fixes))
      (setq file-size (/ file-size power)
            post-fixes (cdr post-fixes)))
    (format "%.0f%s%s" file-size
            (if (and (eq flavor 'iec) (string= (car post-fixes) "k"))
                "K"
              (car post-fixes))
            (if (eq flavor 'iec) "iB" ""))))

;; file size
(defun get-filesize ()
  "Prompt user to enter a file name, with completion and history support."
  (interactive)
  (let* ((data (file-attributes (read-file-name "Enter file name:")))
         (d (nth 7 data)))
    (message "Size is %s" (file-size-human-readable d)))
  )

;(require 'neotree)
;  (global-set-key [f2] 'neotree-toggle)

;; hydra for dired files
(defhydra hydra-files ()
  "files"
  ("h" dired-omit-switch "hidden")
  ("d" dired-hide-details-mode "details")
  ("l" locate "locate")
  ("f" find-alternate-file "find file")
  ("=" dired-equal "=")
  ("t" term-here "terminal")
  ("m" magit-status "magit")
  ("<tab>" dired-subtree-insert "+subtree")
  ("<backtab>" dired-subtree-remove "-subtree")
  ("<backspace>" dired-updirectory "up")
  ("q" nil "cancel" :color blue))

;; main
(use-package dired
  ;;:disabled
  :defer t
  :bind (:map dired-mode-map
              ("C-<f1>" . show-dired-help)
              ("<f7>" . hydra-files/body)
              ("<f2>" . dired-omit-switch)
              ("<f3>" . dired-hide-details-mode)
              ("<f4>" . locate)
              ("<f5>" . find-alternate-file)
              ("<f6>" . dired-equal)
              ("<f10>" . term-here) ;;#'term-here
              ("<f9>"  . magit-status)
              ("<tab>" . dired-subtree-insert)
              ("<backtab>" . dired-subtree-remove)
              ("<backspace>" . dired-up-directory)
              ("C-c C-a" . gnus-dired-attach)
              )
  :init

  ;; dired layout
  (defun dired-layout ()
    (interactive)
    (delete-other-windows)
    (dired launch-directory)
    )

  ;; dired layout
  (defun dired-layout2 ()
    (interactive)
    (delete-other-windows)
    (dired "~/WORK")
    (split-window-right)
    (dired launch-directory)
    )

  :config
  (require 'dired-subtree)
  (require 'dired-rainbow)
  (require 'dired-x)

  ;; If you want Emacs to automatically update a buffer if a file changes on disk,
  ;; auto refresh dired when file changes
  (add-hook 'dired-mode-hook 'auto-revert-mode)

  ;; If nil, don't ask whether to kill buffers visiting deleted files
  (setq dired-clean-confirm-killing-deleted-buffers nil)

  ;; get readable file sizes, dirs first
  (setq dired-listing-switches "-aBhl  --group-directories-first")

  ;; Hide details by default
                                        ;(defun dired-mode-setup ()
                                        ;  "to be run as hook for `dired-mode'."
                                        ;  (dired-hide-details-mode 1))
                                        ;(add-hook 'dired-mode-hook 'dired-mode-setup)

  ;;allow dired to delete or copy dir
  (setq dired-recursive-copies (quote always)) ; “always” means no asking
  (setq dired-recursive-deletes (quote top)) ; “top” means ask once

  ;;How to copy from one dired dir to the next dired dir shown in a split window
  (setq dired-dwim-target t)

  ;;toggle hidden files
  (setq dired-omit-files "^\\...+$")
  (add-hook 'dired-mode-hook (lambda () (dired-omit-mode 1)))

  ;;switch
  (defvar v-dired-omit t
    "If dired-omit-mode enabled by default. Don't setq me.")
  (defun dired-omit-switch ()
    "This function is a small enhancement for `dired-omit-mode', which will
   \"remember\" omit state across Dired buffers."
    (interactive)
    (if (eq v-dired-omit t)
        (setq v-dired-omit nil)
      (setq v-dired-omit t))
    (dired-omit-caller)
    (revert-buffer))
  (defun dired-omit-caller ()
    (if v-dired-omit
        (setq dired-omit-mode t)
      (setq dired-omit-mode nil)))
  (add-hook 'dired-mode-hook 'dired-omit-caller)

  ;; open with external application
  (defun open-in-external-app ()
    "Open the file where point is or the marked files in Dired in external
app. The app is chosen from your OS's preference."
    (interactive)
    (let* ((file-list
            (dired-get-marked-files)))
      (mapc
       (lambda (file-path)
         (let ((process-connection-type nil))
           (start-process "" nil "xdg-open" (shell-quote-argument file-path)))) file-list)))
  (define-key dired-mode-map (kbd "C-<return>") #'open-in-external-app)

  ;;don't try to docview following extensions (with mouse 1)
                                        ;(add-to-list 'auto-mode-alist '("\\.pdf\\'" . fundamental-mode))
  (add-to-list 'auto-mode-alist '("\\.dvi\\'" . fundamental-mode))
  (add-to-list 'auto-mode-alist '("\\.pptx\\'" . fundamental-mode))
  ;;better PDF handling?
  ;;(add-hook 'prog-mode-hook 'linum-on)

  ;; open terminal here
  ;;(defun term-here ()
  ;;  (interactive)
  ;;  (dired-smart-shell-command (concat "terminator --working-directory=\"$PWD\"") nil nil))
  (defun term-here ()
    (multi-term-dedicated))

  ;; have the same on both panels
  (defun dired-equal ()
    (interactive)
    (find-file (dired-dwim-target-directory))
    )

  ;; Lets you copy huge files and directories without Emacs freezing up and with convenient progress bar updates. That is all.
;;;###autoload
  (defun dired-rsync (dest)
    (interactive
     (list
      (expand-file-name
       (read-file-name
        "Rsync to:"
        (dired-dwim-target-directory)))))
    ;; store all selected files into "files" list
    (let ((files (dired-get-marked-files
                  nil current-prefix-arg))
          ;; the rsync command
          (tmtxt/rsync-command
           "rsync -arvz --progress "))
      ;; add all selected file names as arguments
      ;; to the rsync command
      (dolist (file files)
        (setq tmtxt/rsync-command
              (concat tmtxt/rsync-command
                      (shell-quote-argument file)
                      " ")))
      ;; append the destination
      (setq tmtxt/rsync-command
            (concat tmtxt/rsync-command
                    (shell-quote-argument dest)))
      ;; run the async shell command
      (async-shell-command tmtxt/rsync-command "*rsync*")
      ;; finally, switch to that window
      ;; (other-window 1)
      ;; (kill-buffer "*rsync*")
      (switch-to-buffer-other-window "*rsync*")
      ;;(previous-multiframe-window)
      ))
  (define-key dired-mode-map "Y" 'dired-rsync)

  ;; open in new frame
  (defun dired-find-file-other-frame ()
    "In Dired, visit this file or directory in another window."
    (interactive)
    (find-file-other-frame (dired-get-file-for-visit)))
  (eval-after-load "dired"
    '(define-key dired-mode-map (kbd "<C-S-mouse-1>") 'dired-find-file-other-frame))

  ;; colors for extensions
  (defconst my-dired-image-files-extensions
    '("png" "jpg" "jpeg" "tiff" "bmp" "gif" )
    "Image files.")
  (defconst my-dired-media-files-extensions
    '("mp3" "mp4" "MP3" "MP4" "avi" "mpg" "flv" "ogg" "mkv" "mov" "MOV" "webm" "m4a" "wav" )
    "Media files.")
  (defconst my-dired-prog-files-extensions
    '("py" "ipynb" "pro" "php" "c" "f" "f90" "css" "js" )
    "Program files.")
  (defconst my-dired-archive-files-extensions
    '("zip" "tar.gz" "tar" "7z" "rar" "tar.xz" )
    "Program files.")
  (defconst my-dired-docs-files-extensions
    '("pdf" "doc" "docx" "odp" "docx" "ppt" "pptx" )
    "Program files.")
  (defconst my-dired-ebooks-files-extensions
    '("mobi" "epub" )
    "Program files.")
  (dired-rainbow-define docs "#FFFF00" my-dired-docs-files-extensions)
  (dired-rainbow-define docs "#AAFF00" my-dired-docs-files-extensions)
  (dired-rainbow-define image "#99CCFF" my-dired-image-files-extensions)
  (dired-rainbow-define media "#6699FF" my-dired-media-files-extensions)
  (dired-rainbow-define prog "#FF6666" my-dired-prog-files-extensions)
  (dired-rainbow-define archive "#FF3300" my-dired-archive-files-extensions)

                                        ; highlight executable files, but not directories
  (dired-rainbow-define-chmod executable-unix "#999966" "-[rw-]+x.*")

  ;; help
  (defun show-dired-help ()
    (interactive)
    (message-box "
DIRED
-----
<C-x,d>:  go to directory
<s>:      toggle alphabetical/date
<f2>:     toggle dot files
<f3>:     toggle details
<f4>:     locate (use * first if using wildcard in name)
<f5>:     jump to location
<f6>:      =
<f6>:     Hydra
<f10>:    terminal here
<f9>:     magit status (s: stage, cc + C-c C-c: commit, P u: push, F u: pull)
!:        launch shell command on file (& async)
R:        rename
Y:        rsync
g:        refresh
o:        quick view
C-S-mouse1: open in new frame
C-RET:    open externally
C-c C-a:  attach to mu4e buffer
C-0 w:    clipboard copy location
(S)TAB:   subtree
<backspace>: parent directory
"))


  )

;; main
(use-package ranger
  :disabled
  :defer t
  :bind (:map ranger-mode-map
              ("C-<f1>" . show-ranger-help)
              )
  :init

  ;;default file manager
  (ranger-override-dired-mode t)

  ;;When disabling/closing the ranger session, then you can choose to kill the buffers that were opened while browsing the directories.
  (setq ranger-cleanup-on-disable t)
  ;; Or you can choose to kill the buffers, after you move to another entry in the dired buffer.
  (setq ranger-cleanup-eagerly t)

  ;;To show hidden files when ranger starts,
                                        ;(setq ranger-show-hidden t)

  ;;panels
  (setq ranger-parent-depth 2)

  ;;previews
  (setq ranger-preview-file nil)
  (setq ranger-max-preview-size 10) ;;Mb
  (setq ranger-dont-show-binary t)
  (setq ranger-excluded-extensions '("mkv" "iso" "mp4"))

  ;; help
  (defun show-ranger-help ()
    (interactive)
    (message-box "
RANGER
-----
<arrows>:\t navigate
<i>:\t toggle preview panel
<;C>:\t copy (yy: mark)
<R>:\t move/rename (dd: mark)
<pp>:\t paste (po: and override, p?: show copy content)
<D>:\t delete
<;+>:\t create directory
<;=>:\t diff current file with...
<;d>:\t mark for deletion (;x: delete)
<zh>:\t toggle hidden files
<gh>:\t home
<du>:\t du
<!>:\t\t\t launch shell command on file (;& async)
<z-+>:\t add/remove panels
<we>:\t open externally
"))
  )

(defun asciiview (imagefile)
  ;; use asciiview (part of aatools) to render image file as text to buffer
  (interactive "fChoose image file: ")
  (save-excursion
    (with-current-buffer (pop-to-buffer (format "*asciiview %s*" imagefile))
      (insert
       (car (last (butlast
                   (split-string
                    (shell-command-to-string
                     (format
                      "echo q | asciiview -driver stdout -kbddriver stdin %s 2>/dev/null"
                      (shell-quote-argument imagefile)))
                    "^L")))))
      (view-mode))))

(add-to-list 'load-path "~/.local/share/icons-in-terminal/") ;; If it's not already done
(add-to-list 'load-path "~/.emacs.d/sidebar.el/")
(add-to-list 'load-path "~/.emacs.d/font-lock-plus/")
(add-to-list 'load-path "~/.emacs.d/frame-local/")
(require 'sidebar)
(global-set-key (kbd "C-x C-f") 'sidebar-open)
(global-set-key (kbd "C-x C-a") 'sidebar-buffers-open)

(setq sidebar-mu4e-autostart nil) ;;do not start sidebar automatically

(if (version<= "26.0.50" emacs-version )
    (add-hook 'prog-mode-hook 'display-line-numbers-mode) ;only for programming ;(global-linum-mode t) freezes docview
  (add-hook 'prog-mode-hook 'linum-mode) ;only for programming ;(global-linum-mode t) freezes docview
  )

(defun toggle-selective-display (column)
  (interactive "P")
  (set-selective-display
   (or column
       (unless selective-display
         (1+ (current-column))))))

(defun toggle-hiding (column)
  (interactive "P")
  (if hs-minor-mode
      (if (condition-case nil
              (hs-toggle-hiding)
            (error t))
          (hs-show-all))
    (toggle-selective-display column)))
(load-library "hideshow")

(use-package elpy
  :defer t
  :bind (:map elpy-mode-map
              ("C-<f1>" . show-elpy-help)
              ("<f2>" . elpy-shell-switch-to-shell)
              ("C-<f2>" . elpy-shell-switch-to-shell-below)
              ("<f3>" . elpy-shell-send-statement)
              ("<f4>" . elpy-shell-send-region-or-buffer)
              ("C-<tab>" . toggle-hiding)
              )
  :hook (elpy-mode . hs-minor-mode)
                                        ;(add-hook 'elpy-mode-hook   'hs-minor-mode)
  :init
  ;; elpy layout

  (defun elpy-layout ()
    (interactive)
    (delete-other-windows)
    (find-file "~/ownCloud/Python/Library")
    (elpy-shell-switch-to-shell)
    (previous-multiframe-window)
    (split-window-vertically) 
    (dired launch-directory)
                                        ;(split-window-vertically (floor (* 0.75 (window-height))))
                                        ;(dired "~/")
                                        ;(split-window-right)
                                        ;(find-file "~/ownCloud/Python/Library")
    )

  (elpy-enable)
  :config

  ;;guess indent?
  (setq python-indent-guess-indent-offset t)  
  (setq python-indent-guess-indent-offset-verbose nil)

  (setq python-shell-interpreter "ipython3"
        python-shell-interpreter-args "--simple-prompt --pprint") ;;Since IPython 5 it has a new terminal interface, which is not compatible with Emacs’ inferior shells. To fix it, add the --simple-prompt flag to the IPython command:



  ;;
  (setenv "JUPYTER_CONSOLE_TEST" "1")
  (add-to-list 'python-shell-completion-native-disabled-interpreters "ipython3")
  (add-to-list 'python-shell-completion-native-disabled-interpreters "jupyter")

  (setq
   python-shell-prompt-detect-enabled nil
   python-shell-interpreter "jupyter"
   python-shell-interpreter-args "console"
   )
  ;; 

  ;; 
  (setq elpy-shell-send-region-or-buffer 0)
  (setq elpy-shell-switch-to-shell 0)

  ;;use %matplotlib

  ;;indent with highlight-indent-guides
  (add-hook 'elpy-mode-hook (lambda () (highlight-indentation-mode -1)))

  ;; use flycheck not flymake with elpy
  (when (require 'flycheck nil t)
    (setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
    (add-hook 'elpy-mode-hook 'flycheck-mode))

                                        ;remove flycheck and flymake
                                        ;(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
                                        ;(setq elpy-modules (delq 'elpy-module-flycheck elpy-modules))

                                        ;(setq python-shell-interpreter "jupyter"
                                        ;      python-shell-interpreter-args "console --simple-prompt") ;;Since IPython 5 it has a new terminal interface, which is not compatible with Emacs’ inferior shells. To fix it, add the --simple-prompt flag to the IPython command:


                                        ;(setq python-shell-prompt-detect-failure-warning nil)
                                        ;(setq python-shell-prompt-detect-enabled nil)
                                        ;(elpy-use-ipython)

  (defun elpy-shell-switch-to-shell-below ()
    (interactive)
    (split-window-vertically (floor (* 0.75 (window-height))))
    (previous-multiframe-window)
    (elpy-shell-switch-to-shell-in-current-window)
    (previous-multiframe-window)
    (delete-window)
    )


  ;; help
  (defun show-elpy-help ()
    (interactive)
    (message-box "
ELPY
----
<f2>:       run interpreter
<f3>:       eval statement
<f4>:       eval region
<C-RET>:    eval statement & step
<C-arrows>: navigate interpreter
<M-arrows>: indent blocks
<C-c C-o>:  outline
<C-TAB>:    toggle show/hide

EIN
---
py & C-f7:    insert block snippet
M-x ein:run : launch ein
<C-c C-o>:    open dir
<C-x C-s>:    save
<C-x C-w>:    rename
<C-c C-a>:    insert cell above
<C-c C-b>:    insert cell below
<C-c C-k>:    kill cell
<C-c C-c>:    execute
<M-RET>  :    execute and next cell
<CM-arrows>:  move
"))

  )

;;syntax coloring
;; ## sudo apt-get install php-elisp

(use-package php-mode
  :defer t
  )

(use-package web-mode
  :defer t
  :init
  (add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.[agj]sp\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode)))

(use-package highlight-indent-guides
  :hook
  (python-mode . highlight-indent-guides-mode)
  :custom
  (highlight-indent-guides-method 'character)
  (highlight-indent-guides-responsive 'top)
  (highlight-indent-guides-delay 0)
  )
(add-hook 'prog-mode-hook 'highlight-indent-guides-mode)


;; indent automatically and live

                                        ;(add-hook 'emacs-lisp-mode-hook #'aggressive-indent-mode)
                                        ;(add-hook 'css-mode-hook #'aggressive-indent-mode)

                                        ;(global-aggressive-indent-mode 1)
                                        ;(add-to-list 'aggressive-indent-excluded-modes 'html-mode)

(use-package aggressive-indent
  :preface
  (defun me/aggressive-indent-mode-off ()
    (aggressive-indent-mode 0))
  :hook
  ((css-mode . aggressive-indent-mode)
   (emacs-lisp-mode . aggressive-indent-mode)
   (js-mode . aggressive-indent-mode)
   (lisp-mode . aggressive-indent-mode)
   (sgml-mode . aggressive-indent-mode))
  :custom
  (aggressive-indent-comments-too t)
  :config
  (add-to-list 'aggressive-indent-protected-commands 'comment-dwim))

                                        ;pip install --upgrade pip
                                        ;pip install --upgrade ipython (possibly pip install ipython==6.5.0 to avoid problems with prompt-toolkit)
                                        ;pip install --upgrade pyzmq
                                        ;pip install --upgrade jupyter

                                        ;install ob-ipython package

;;https://github.com/gregsexton/ob-ipython

(use-package ob-python
                                        ;:ensure t
  :config
  ;; Org-babel
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)
     (lisp . t)
                                        ;(fortran . t)
                                        ;(C . t)
                                        ;(shell . t)
     ;;(http . t)
                                        ;(latex . t)
                                        ;(ipython . t) ;;Enabling it makes org-capture fail, see https://github.com/syl20bnr/spacemacs/issues/9941
     ))
  (setq org-confirm-babel-evaluate nil)  ;don't prompt me to confirm everytime I want to evaluate a block
  (add-hook 'org-babel-after-execute-hook 'org-display-inline-images 'append);;; display/update images in the buffer after I evaluate
  )

;; use package python-mode causes issues
                                        ;(setq python-shell-interpreter "ipython3"
                                        ;      python-shell-interpreter-args  "--simple-prompt -i"
                                        ;      python-indent-offset 4) ;;Since IPython 5 it has a new terminal interface, which is not compatible with Emacs’ inferior shells. To fix it, add the --simple-prompt flag to the IPython command:



;;   :session mysession :results raw drawer :exports both #:ipyfile /tmp/image.png #:async t

;;%matplotlib inline 

;; yasnippet
                                        ;# -*- mode: snippet -*-
                                        ;# name: ipython block
                                        ;# key: py
                                        ;# --
                                        ;#+BEGIN_SRC ipython :session ${1::ipyfile ${2:$$(let ((temporary-file-directory "./")) (make-temp-file "py" nil ".png"))} }:exports ;${3:both}
                                        ;$0
                                        ;#+END_SRC

;; or 
                                        ;#+BEGIN_SRC ipython :session :exports both :results raw drawer
                                        ;  $0
                                        ;#+END_SRC

;;(ob-ipython-kill-kernel)

;;(setq abbrev-file-name '')

(use-package ein
  :defer t
  :config
  ;; Org-babel ;;in config otherwise slows down regular python file
  (org-babel-do-load-languages
   'org-babel-load-languages
   '( 
     (ein . t)
                                        ;(emacs-lisp . t)
                                        ;(lisp . t)
                                        ;(fortran . t)
                                        ;(C . t)
                                        ;(shell . t)
     ;;(http . t)
                                        ;(latex . t)
                                        ;(ipython . t) ;;Enabling it makes org-capture fail, see https://github.com/syl20bnr/spacemacs/issues/9941
     ))
  )

;; 2007
;; vianney xxx
;; phdthesis xxx
;; eye.?tracking
;; 2010 and 2011: \(2010\|2011\)
;; article xxx kunth
;; article caplan !kunth

;; actions
                                        ;(helm-add-action-to-source
                                        ; "Open annotated PDF (if present)" 'helm-bibtex-open-annotated-pdf
                                        ; helm-source-bibtex 1)

;; helm-bibtex
(use-package helm-bibtex
  :defer t
  :bind (:map helm-map ("C-<f1>" . show-helm-bibtex-help))
  :init
  ;;helm-bibtex
  (setq bibtex-completion-bibliography '("~/ownCloud/bibtexendum/bibtexendum.bib"))
  (setq bibtex-completion-notes-path "~/ownCloud/bibtexendum/bibtexendum_notes.org") ;; use directory if one per publication (setq bibtex-completion-notes-path "/path/to/notes") (setq bibtex-completion-notes-extension ".org")

  ;;PDFs
  (setq bibtex-completion-library-path '("~/ownCloud/bibtexendum/PDFLibrary/"))
  (setq bibtex-completion-pdf-field "File")

  ;; searching
  ;; default fields used for searching are: author, title, year, BibTeX key, entry type (article, inproceedings, …)
  (setq bibtex-completion-additional-search-fields '(firstauthor tags))

  ;; available pdf or notes
  (setq bibtex-completion-pdf-symbol "⌘")
  (setq bibtex-completion-notes-symbol "✎")

  (setq bibtex-completion-display-formats
        '((article       . "${=has-pdf=:1}${=has-note=:1}| ${=type=:3}| ${year:4}| ${author:25}| ${title:*} ")
          (inbook        . "${=has-pdf=:1}${=has-note=:1}| ${=type=:3}| ${year:4}| ${author:25}| ${title:*} ")
          (incollection  . "${=has-pdf=:1}${=has-note=:1}| ${=type=:3}| ${year:4}| ${author:25}| ${title:*} ")
          (inproceedings . "${=has-pdf=:1}${=has-note=:1}| ${=type=:3}| ${year:4}| ${author:25}| ${title:*} ")
          (t             . "${=has-pdf=:1}${=has-note=:1}| ${=type=:3}| ${year:4}| ${author:25}| ${title:*}")))

  (defun helm-bibtex-my-publications (&optional arg)
    "Search BibTeX entries authored by “Jane Doe”.
  With a prefix ARG, the cache is invalidated and the bibliography reread."
    (interactive "P")
    (helm-bibtex arg nil "xxx"))
  ;; Bind this search function to Ctrl-x p:
  (global-set-key (kbd "C-x p") 'helm-bibtex-my-publications)

  (global-set-key (kbd "C-x B") 'helm-bibtex)
  (global-set-key (kbd "C-x r") 'helm-resume)


  (defun show-helm-bibtex-help ()
    (interactive)
    (message-box "
helm-bibtex
-----------

C-SPACE: mark
TAB: actions 
ENTER: default action
helm-resume
"))
  )

                                        ;(defun run-bibtexendum (args)
                                        ;  (interactive "sInput arguments (e.g., -a xxxx.yyyy): ")
                                        ;  (eshell)
                                        ;  (with-current-buffer "*eshell*"
                                        ;    (message "Arguments: %s" args)
                                        ;    (eshell-return-to-prompt)
                                        ;    (insert "cd ~/ownCloud/bibtexendum/")
                                        ;    (eshell-send-input)
                                        ;    (insert (concat "python bibtexendum.py " args))
                                        ;    (eshell-send-input))
                                        ;  )


(defun multi-term-bibtexendum2 (args);
  ;(interactive)
                                        ;(defun multi-term-bibtexendum (args);
  (interactive "sInput argument(s) (e.g., -a xxxx.yyyy): ")
  (multi-term-dedicated-open)
  (with-current-buffer "*MULTI-TERM-DEDICATED*"
    (toggle-read-only)
    (insert (concat "\cd ~/ownCloud/bibtexendum; python bibtexendum.py " args)) 
    (term-send-input)
    ))

(defun multi-term-bibtexendum ();
  ;(interactive)
                                        ;(defun multi-term-bibtexendum (args);
  ;;(interactive "sInput argument(s) (e.g., -a xxxx.yyyy): ")
  (multi-term-dedicated-open)
  (with-current-buffer "*MULTI-TERM-DEDICATED*"
    (toggle-read-only)
    (insert (concat "\cd ~/ownCloud/bibtexendum; python bibtexendum.py " (read-string "Input argument(s) (e.g., -a xxxx.yyyy): "))) 
                                        ;(insert (concat "python bibtexendum.py " args) 
    (term-send-input)
    ))

;;(defun multi-term-foo ()
;;  (interactive)
;;  "Make a multi-term buffer running foo."
;;  (let ((multi-term-program (concat "\cd ~/ownCloud/bibtexendum; python bibtexendum.py " (read-string "Input argument(s) (e.g., -a xxxx.yyyy): "))))
;;    (multi-term)))

;; Shortcuts for bibtexendum
(global-set-key "\C-cx" 'multi-term-bibtexendum2)

;; shortcuts emacs keeps for itself
;; remove C-zxc
(defcustom term-unbind-key-list
  '("C-x" "C-c" "C-h" "C-y" "<ESC>")
  "The key list that will need to be unbind."
  :type 'list
  :group 'multi-term)

;; check if we're at CEA or not (e.g., for mu4e contexts)
(defun process-exit-code-and-output (program &rest args)
  "Run PROGRAM with ARGS and return the exit code and output in a list."
  (with-temp-buffer 
    (list (apply 'call-process program nil (current-buffer) nil args)
          (buffer-string))))

;;more /usr/bin/hostalive 
;;#!/bin/bash
;;echo `nmap -Pn -p 22 T5 $1 | grep -c -e "filtered" -e "0 hosts up"` 
(defun check-if-at-CEA ()
  (interactive)
  (string= "1" (substring (format "%s" (process-exit-code-and-output "hostalive_ssh" "xxx.fr")) 3 4))
  )
(add-hook 'mu4e-default-hook
          (progn
            (setq at-cea (string= "1" (substring (format "%s" (process-exit-code-and-output "hostalive_ssh" "xxx.fr")) 3 4)) ))
          (if at-cea
              (message "@CEA")
            (message "not @CEA"))
          )

;;match strings in list and inversely
(defun xah-string-match-in-list-p (@str @list-of-string @match-case-p &optional @reverse-contain-p)
  "If @str occur in list @list-of-string, return true (the first element), else nil.
if @reverse-contain-p is true, change the direction of match. That is, true if any element in @list-of-string occur in @str.
@match-case-p determines whether case is literal for the match.
No regex is used.
Existing match data is changed. Wrap it with `save-match-data' if you need it restored.
URL `http://ergoemacs.org/emacs/elisp_string_match_in_list.html'
Version 2016-07-18"
  (let ((case-fold-search (not @match-case-p)))
    (if @reverse-contain-p
        (catch 'tag
          (mapc
           (lambda ($x)
             (when (string-match (regexp-quote $x) @str ) (throw 'tag $x)))
           @list-of-string)
          nil)
      (catch 'tag
        (mapc
         (lambda ($x)
           (when (string-match (regexp-quote @str) $x ) (throw 'tag $x)))
         @list-of-string)
        nil))))

;;get list of keys
(defun alist-keys (alist)
  (mapcar 'car alist))

                                        ;(setq undo-limit 500) ;that's in bytes

;; undo-tree
(use-package undo-tree
  :defer t
  :diminish undo-tree-mode
  :config
  (progn
    (global-undo-tree-mode)
    (setq undo-tree-visualizer-timestamps t)
    (setq undo-tree-visualizer-diff t)))

(use-package magit
  :defer t
  :bind (:map magit-mode-map
              ("C-<f1>" . show-magit-help))
  :bind (:map magit-hunk-section-map
              ("RET" . magit-diff-visit-file-other-window)
              ([return] . magit-diff-visit-file-other-window))
  :custom
  (magit-display-buffer-function 'magit-display-buffer-same-window-except-diff-v1)
  (magit-diff-highlight-hunk-body nil)
  (magit-diff-highlight-hunk-region-functions
   '(magit-diff-highlight-hunk-region-dim-outside magit-diff-highlight-hunk-region-using-face))
  (magit-popup-display-buffer-action '((display-buffer-same-window)))
  (magit-refs-show-commit-count 'all)
  (magit-section-show-child-count t)
  :config
  (magit-section-cycle-diffs) ;; do it once to collapse everything
  (remove-hook 'magit-section-highlight-hook #'magit-section-highlight)
  ;; help
  (defun show-magit-help ()
    (interactive)
    (message-box "
MAGIT
-----
s/u:     stage/unstage
cc:      commit
C-c C-c: accept commit
Pu:      push
Fu:      pull 
"))
  )
(global-set-key (kbd "C-x g") 'magit-status)

;; based on emacs-wttrin
;;alias wtr='curl -s wttr.in/orsay?3qFm & curl -s wttr.in/{orsay,champfleur,northridge}?format="%l:+%c+(%C),%h,%t,%m,%w,%p,%P" '
(require 'url)

(defgroup wtr nil
  "Emacs frontend for weather web service wttr.in."
  :prefix "wtr-"
  :group 'comm)

(defcustom wtr-default-cities '("orsay" "champfleur" "northridge")
  "Specify default cities list for quick completion."
  :group 'wtr
  :type 'list)

(defcustom wtr-default-accept-language '("Accept-Language" . "en-US,en;fr-FR,fr")
  "Specify default HTTP request Header for Accept-Language."
  :group 'wtr
  :type '(list)
  )

(defun wtr-fetch-raw-string (query)
  "Get the weather information based on your QUERY."
  (let ((url-request-extra-headers '(("User-Agent" . "curl"))))
    (add-to-list 'url-request-extra-headers wtr-default-accept-language)
    (with-current-buffer
        (url-retrieve-synchronously
         (concat "http://wttr.in/" query "?m3qFT")
         (lambda (status) (switch-to-buffer (current-buffer))))
      (decode-coding-string (buffer-string) 'utf-8))))

(defun wtr-fetch-raw-string2 (query)
  "Get the weather information based on your QUERY."
  (let ((url-request-extra-headers '(("User-Agent" . "curl"))))
    (add-to-list 'url-request-extra-headers wtr-default-accept-language)
    (with-current-buffer
        (url-retrieve-synchronously
         (concat "http://wttr.in/" query "?format=\"%l:+%c+(%C), %h, %t, %m, %w, %p, %P&m\"") 
         (lambda (status) (switch-to-buffer (current-buffer))))
      (decode-coding-string (buffer-string) 'utf-8))))

(defun wtr-fetch-raw-string3 ()
  "Get the weather information based on your QUERY."
  (let ((url-request-extra-headers '(("User-Agent" . "curl"))))
    (add-to-list 'url-request-extra-headers wtr-default-accept-language)
    (with-current-buffer
        (url-retrieve-synchronously "http://wttr.in/moon?m3qFT") 
      (lambda (status) (switch-to-buffer (current-buffer)))
      (decode-coding-string (buffer-string) 'utf-8))))

(defun wtr-exit ()
  (interactive)
  (quit-window t))

(defun wtr-query (city-name)
  "Query weather of CITY-NAME via wtr, and display the result in new buffer."
  (let ((raw-string (wtr-fetch-raw-string city-name))
        (raw-string2 (wtr-fetch-raw-string2 city-name))
        (raw-string3 (wtr-fetch-raw-string3)))
    (if (string-match "ERROR" raw-string)
        (message "Cannot get weather data. Maybe you inputed a wrong city name?")
      (let ((buffer (get-buffer-create (format "*wttr.in - %s*" city-name))))
        (switch-to-buffer buffer)
        (setq buffer-read-only nil)
        (erase-buffer)

        (insert (propertize raw-string3 'face `(:family "Monospace")))
        (goto-char (point-min))
        (re-search-forward "^$")
        (delete-region (point-min) (1+ (point)))

        (insert (propertize raw-string 'face `(:family "Monospace")))
        (goto-char (point-min))
        (re-search-forward "^$")
        (delete-region (point-min) (1+ (point)))

        (insert (concat (propertize raw-string2 'face `(:family "Monospace")) "\n"))
        (goto-char (point-min))
        (re-search-forward "^$")
        (delete-region (point-min) (1+ (point)))

        (insert (concat "\n" (sunrise-sunset) "\n" "\n"))

        (use-local-map (make-sparse-keymap))
        (local-set-key "q" 'wtr-exit)
        (local-set-key "g" 'wtr)
        (setq buffer-read-only t)))))

;;;###autoload
(defun wtr (city)
  "Display weather information for CITY."
  (interactive
   (list
    (completing-read "City name: " wtr-default-cities nil nil
                     (when (= (length wtr-default-cities) 1)
                       (car wtr-default-cities)))))

  ;; check lat/lon ;; latlong.net
  (if (string= city "orsay")
      (progn (setq calendar-latitude 48.699010)
             (setq calendar-longitude 2.187860)
             (setq calendar-location-name "Orsay, France")))

  (if (string= city "champfleur")
      (progn (setq calendar-latitude 48.386670)
             (setq calendar-longitude 0.125470)
             (setq calendar-location-name "Champfleur, France")))

  (if (string= city "northridge")
      (progn (setq calendar-latitude 34.288471)
             (setq calendar-longitude -118.478394)
             (setq calendar-location-name "Northridge, CA, US")))

  (wtr-query city))

(provide 'wtr)

;;calendar timezones
(set-time-zone-rule "CET")
(setq org-icalendar-timezone "CET")

;; timezones
;;https://github.com/emacs-mirror/emacs/blob/master/lisp/timezone.el
(makunbound 'display-time-world-list)
(defvar display-time-world-list
  `( ("UT" "UT")
     ("America/New_York" "New York")
     ("America/Los_Angeles" "Los Angeles")
     ("Europe/Paris" "Paris")
     ))
;; (setq display-time-world-time-format "[%Z] %a %d %b %R")
;;(global-set-key "\C-ct" 'display-time-world-list)


(defun worldtime-exit ()
  (interactive)
                                        ;(quit-window t)
  (delete-window))

(defun my-worldtime-display ()
  (interactive)
  (display-time-world)
  (next-multiframe-window)
  (delete-window)
  ;;
                                        ;(split-window-below)
  (split-window-vertically (floor (* 0.85 (window-height))))
  (next-multiframe-window)
  (switch-to-buffer "*wclock*")
  (local-set-key "q" 'worldtime-exit)
                                        ;(previous-multiframe-window)
  )
(global-set-key "\C-cT" 'my-worldtime-display)

(use-package calfw
  :defer 1
  :bind ((:map cfw:calendar-mode-map
               ("C-<f1>" . show-cfw-help)
               ("r" . cfw-refresh)
         ))
  :init
  (require 'calfw-org)
  (require 'calfw-ical)
  (setq cfw:org-overwrite-default-keybinding t)
  ;;(toggle-frame-maximized)
  ;;(set-frame-parameter nil 'fullscreen 'maximized)

  :config
  ;; Month
  (setq calendar-month-name-array
        ["January" "February" "March"     "April"   "May"      "June"
         "July"    "August"   "September" "October" "November" "December"])
  ;; Week days
  (setq calendar-day-name-array
        ["Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday"])
  ;; First day of the week
  (setq calendar-week-start-day 1) ; 0:Sunday, 1:Monday

  (custom-set-faces
   '(cfw:face-title ((t (:foreground "#f0dfaf" :weight bold :height 2.0 :inherit variable-pitch))))
   ;;weekdays
   '(cfw:face-header ((t (:foreground "#cc9393" :background "black" :weight bold))))
   '(cfw:face-sunday ((t :foreground "#d0bf8f" :background "black" :weight bold)))
   '(cfw:face-saturday ((t :foreground "#d0bf8f" :background "black" :weight bold)))
   ;;
   '(cfw:face-holiday ((t :background "#808080" :foreground "#505090" :weight bold)))
   ;;
   '(cfw:face-grid ((t :foreground "#808080")))
   ;;
   '(cfw:face-default-content ((t :foreground "#bfebbf")))
   '(cfw:face-periods ((t :foreground "white")))
   ;;day number
   '(cfw:face-day-title ((t :background "grey10")))
   '(cfw:face-default-day ((t :weight bold :inherit cfw:face-day-title)))
   '(cfw:face-annotation ((t :foreground "RosyBrown" :inherit cfw:face-day-title)))
   '(cfw:face-disable ((t :foreground "DarkGray" :inherit cfw:face-day-title)))
   '(cfw:face-today-title ((t :background "#104020" :weight bold)))
   '(cfw:face-today ((t :background: "#505050" :weight bold)))
   '(cfw:face-select ((t :background "#505070")))
   '(cfw:face-toolbar ((t :foreground "Steelblue4" :background "black")))
   '(cfw:face-toolbar-button-off ((t :foreground "Gray10" :background "white" :weight bold)))
   '(cfw:face-toolbar-button-on ((t :foreground "Gray50" :background "white":weight bold))))

;; Default setting
(setq cfw:fchar-junction ?+
      cfw:fchar-vertical-line ?|
      cfw:fchar-horizontal-line ?-
      cfw:fchar-left-junction ?+
      cfw:fchar-right-junction ?+
      cfw:fchar-top-junction ?+
      cfw:fchar-top-left-corner ?+
      cfw:fchar-top-right-corner ?+ )
)

;; Calendar view for org-agenda.
  (with-eval-after-load "calfw-org"
    ;; Remove some strings (tags and filenames) from item summary.
    (defun cfw:org-summary-format (item)
      "Format an item (How should it be displayed?)."
      (let* ((time (cfw:org-tp item 'time))
             (time-of-day (cfw:org-tp item 'time-of-day))
             (time-str (and time-of-day
                            (format "%02i:%02i "
                                    (/ time-of-day 100)
                                    (% time-of-day 100))))
             (category (cfw:org-tp item 'org-category))
             (tags (cfw:org-tp item 'tags))
             (marker (cfw:org-tp item 'org-marker))
             (buffer (and marker (marker-buffer marker)))
             (text (cfw:org-extract-summary item))
             (props (cfw:extract-text-props item 'face 'keymap)))
        (propertize
         (concat
          (if time-str (apply 'propertize time-str props)) text " "
          ;; (and buffer (buffer-name buffer))
          )
         'keymap cfw:org-text-keymap
         ;; Delete the display property, since displaying images will break our
         ;; table layout.
         'display nil))))


;(require 'org-gcal)
;(setq org-gcal-client-id ".apps.googleusercontent.com"
;      org-gcal-client-secret "your-secret"
;      org-gcal-file-alist '(("your-mail@xxx.com" .  "~/ownCloud/org/gcal2org/schedule.org")
;                            ("another-mail@xxx.com" .  "~/ownCloud/org/gcal2org/task.org")))

(defun cfw-refresh ()
  (interactive)
  (call-interactively 'cfw:refresh-calendar-buffer)
  (when (get-buffer "*Org Agenda(A)*")
    (switch-to-buffer-other-frame "*Org Agenda(A)*")
    (org-agenda-redo-only-nocfw))
  )

(defun cfw-here ()
  (interactive)
(let ((buf (get-buffer "*cfw-calendar*")))
    (if buf
        (pop-to-buffer buf nil)
      (cfw:open-calendar-buffer
       :contents-sources
       (list
        (cfw:org-create-source "#F0F020")
             )
       :view 'two-weeks)
      ))
)
(defun cfw ()
  (interactive)
  (select-frame (make-frame))
  (delete-other-windows)
  (let ((buf (get-buffer "*cfw-calendar*")))
    (if buf
        (pop-to-buffer buf nil)
      (cfw:open-calendar-buffer
       :contents-sources
       (list
        (cfw:org-create-source "#F0F020")
             )
       :view 'two-weeks)
      ))
)

      ;; (cfw:org-create-file-source "Success" my-success-cal "#baffc9")
      ;; (cfw:org-create-file-source "Success Atom" my-success-atom-cal "#E3FFE9")
      ;; (cfw:org-create-file-source "Moment" my-moment-cal "#bae1ff")
      ;; (cfw:org-create-file-source "Target" my-target-cal "#40e0d0")
      ;; (cfw:org-create-file-source "Hevent" my-hevent-cal "#ffb3ba"))))


;(use-package calfw-gcal
;:ensure t
;:config
;(require 'calfw-gcal))

;; (custom-set-faces
;;  ;; custom-set-faces was added by Custom.
;;  ;; If you edit it by hand, you could mess it up, so be careful.
;;  ;; Your init file should contain only one such instance.
;;  ;; If there is more than one, they won't work right.
;;  '(cfw:face-annotation ((t :foreground "RosyBrown" :inherit cfw:face-day-title)))
;;  '(cfw:face-day-title ((t :background "grey10")))
;;  '(cfw:face-default-content ((t :foreground "#bfebbf")))
;;  '(cfw:face-default-day ((t :weight bold :inherit cfw:face-day-title)))
;;  '(cfw:face-disable ((t :foreground "DarkGray" :inherit cfw:face-day-title)))
;;  '(cfw:face-grid ((t :foreground "DarkGrey")))
;;  '(cfw:face-header ((t (:foreground "#d0bf8f" :weight bold))))
;;  '(cfw:face-holiday ((t :background "grey10" :foreground "#8c5353" :weight bold)))
;;  '(cfw:face-periods ((t :foreground "cyan")))
;;  '(cfw:face-saturday ((t :foreground "#8cd0d3" :background "grey10" :weight bold)))
;;  '(cfw:face-select ((t :background "yellow" :foreground "black")))
;;  '(cfw:face-sunday ((t :foreground "#cc9393" :background "grey10" :weight bold)))
;;  '(cfw:face-title ((t (:foreground "#f0dfaf" :weight bold :height 2.0 :inherit variable-pitch))))
;;  '(cfw:face-today ((t :background: "Gray" :weight bold)))
;;  '(cfw:face-today-title ((t :background "#7f9f7f" :weight bold)))
;;  '(cfw:face-toolbar ((t :foreground "Steelblue4" :background "Steelblue4")))
;;  '(cfw:face-toolbar-button-off ((t :foreground "White" :weight bold)))
;;  '(cfw:face-toolbar-button-on ((t :foreground "Gray" :weight bold)))
;;  )

;;(defun use-cfw-font ()
;;  (interactive)
;;  "Switch the current buffer to a monospace font."
;;  (face-remap-add-relative 'default '(:family "Ubuntu Mono" :height 80))
;;  (add-hook 'cfw:calendar-mode-hook 'use-cfw-font))

;;fix to avoid multiple ranges
(defun cfw:org-get-timerange (text)
  "Return a range object (begin end text).
If TEXT does not have a range, return nil."
  (let* ((dotime (cfw:org-tp text 'dotime)))
    (and (stringp dotime) (string-match org-ts-regexp dotime)
     (let* ((matches  (s-match-strings-all org-ts-regexp dotime))
           (start-date (nth 1 (car matches)))
           (end-date (nth 1 (nth 1 matches)))
           (extra (cfw:org-tp text 'extra)))
       (if (string-match "(\\([0-9]+\\)/\\([0-9]+\\)): " extra)
       ( list( calendar-gregorian-from-absolute
       (time-to-days
       (org-read-date nil t start-date))
       )
       (calendar-gregorian-from-absolute
       (time-to-days
       (org-read-date nil t end-date))) text)
       )))))

;(defun my--cfw:open-calendar-buffer-view (orig-func &rest args &allow-other-keys)
;  (apply orig-func :view 'two-weeks :allow-other-keys t args)
;  )
;(advice-add 'cfw:open-calendar-buffer :around #'my--cfw:open-calendar-buffer-view)

(defun show-cfw-help ()
    (interactive)
    (message-box "
CALFW
-----

g:         goto date
r:         refresh
k:         capture
x:         close all
t:         today
D,T,W,M:   day, 2-weeks, week, month view
<SPACE>  : popup detail buffer
"))

;; default browser function
(setq browse-url-browser-function 'eww-browse-url)
                                        ;(setq browse-url-browser-function 'browse-url-firefox)
                                        ;(setq browse-url-browser-function 'browse-url-chromium)

;; default browser program
(setq browse-url-generic-program "brave-browser")
;;(setq browse-url-generic-program "vivaldi")

;; example
                                        ;(setq browse-url-browser-function 'browse-url-generic
                                        ;      browse-url-generic-program "brave-browser")

;; default
(setq current-browser "external")
(setq browse-url-browser-function 'browse-url-generic)

;; toggle between eww and external browser
(defun toggle-browser ()
  "Toggle between browsers"
  (interactive)
  (setq current-browser (if (string= current-browser "internal") "external" "internal"))
  (message current-browser)
  (if (string= current-browser "internal")
      (setq browse-url-browser-function 'eww-browse-url)
    (setq browse-url-browser-function 'browse-url-generic)
    )
  )

(defhydra hydra-eww ()
  "eww"
  ("b" eww-back-url "Back")
  ("f" eww-forward-url "Forward")
  ("g" eww-browse-with-external-browser "External")
  ("h" eww-list-histories "History")
  )

(defun vl-eww-hook ()
  (define-key eww-mode-map "?" 'hydra-eww/body))
(add-hook 'eww-mode-hook 'vl-eww-hook)

(add-to-list 'load-path "~/.emacs.d/edit-server")
(require 'edit-server)
(edit-server-start)

;(setq line-spacing 0.2)

(when (memq window-system '(mac ns x)) (exec-path-from-shell-initialize))

                                        ;(setq inverse-video t)
                                        ;(setq mode-line-inverse-video t)



(require 'multiple-cursors)
(global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
                                        ;(global-set-key (kbd "C->") 'mc/mark-next-like-this)
                                        ;(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
                                        ;(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
(global-set-key (kbd "C-S-<mouse-1>") 'mc/add-cursor-on-click)

                                        ;transparent background ;;active/inactive
                                        ;(set-frame-parameter (selected-frame) 'alpha '(98 . 70))
                                        ;(add-to-list 'default-frame-alist '(alpha . (98 . 70)))

(add-hook 'org-mode-hook 'toc-org-mode)

;; Garbage-collect on focus-out, Emacs should feel snappier.
(add-hook 'focus-out-hook #'garbage-collect)

(org-reload)

;;lets you write something like = uconv(33 mi, km)
(with-eval-after-load 'calc
    (defalias 'calcFunc-uconv 'math-convert-units)
    )

(defun lcalc ()
  (interactive)
  (let ((buffer (get-buffer-create (format "*calc.in"))))
    (switch-to-buffer buffer)
    (literate-calc-mode)
    (insert "LITERATE-CALC-MODE
Cheat sheet
-----------
- uconv(33 mi, km)
- round(pi, 2)
- evalv(pi), uconv(c, m/s), uconv(c, 1) to eval default with unit
- tab = [1 2 3]
- log/ln, log10, e, exp, 
-----------

")
    ))

                                        ;(add-to-list 'load-path "~/.emacs.d/popup-kill-ring")
                                        ;(use-package popup-kill-ring
                                        ;  :bind ("C-y" . popup-kill-ring)
                                        ;  )
(defun view-kill ()
  (interactive)
  (save-excursion
    (save-window-excursion
      (let ((working-buffer (current-buffer))
            (new-buffer (get-buffer-create "kill-ring-view"))
            (count 0)
            (custom-map (copy-keymap minibuffer-local-map))
            (selection nil)
            )      
        (unwind-protect
            (progn
              (define-key custom-map " " 'scroll-other-window)

              (switch-to-buffer new-buffer t)
              (delete-other-windows)

              (dolist (x kill-ring)
                (insert (concat "----- " 
                                (number-to-string count) 
                                " -----"))
                (newline)
                (insert x)
                (newline)
                (newline)
                (setq count (+ count 1))
                )
              (goto-char (point-min))

              (let ((choice (read-from-minibuffer "choose: " nil custom-map t nil)))
                (and (numberp choice)
                     (< choice count)
                     (progn
                       (set-buffer working-buffer)
                       (insert (nth choice kill-ring))
                       (setq selection choice)
                       ))
                ))
          (kill-buffer new-buffer) ; unwind-protect clean-up form
          )
        selection
        ))))
(global-set-key (read-kbd-macro "M-y") 'view-kill)

IMAPAccount xxx
# Address to connect to
Host imap.xxx.com
User myname@xxx.com
# Pass passwordinclearsobadidea
# To store the password in an encrypted file use PassCmd instead of Pass
PassCmd "gpg2 -q --for-your-eyes-only --no-tty -d ~/.authinfo.gpg | awk '/machine imap.xxx.com login myname@xxx.com/ {print $NF}'"

# Port 993
# Use SSL
AuthMechs Login
SSLType IMAPS
#SSLVersions SSLv3
# Try one of the following
CertificateFile /etc/ssl/certs/ca-certificates.crt
#CertificateFile /opt/local/share/curl/curl-ca-bundle.crt
#CertificateFile ~/.cert/imap.xxx.com.pem
#CertificateFile ~/.cert/Equifax_Secure_CA.pem
#CertificateFile /etc/ssl/certs/ca-bundle.crt

#------------------------------------------------------------------

IMAPStore xxx-remote
Account xxx

MaildirStore xxx-local
# The trailing "/" is important
Path ~/.mail/xxx/
Inbox ~/.mail/xxx/Inbox

#------------------------------------------------------------------

Channel xxx-inbox
Master :xxx-remote:
Slave :xxx-local:
Patterns "INBOX"
Create Both
Expunge Both
SyncState *

#can choose a different name for local
Channel xxx-mylabel1
Master :xxx-remote:"label1"
Slave :xxx-local:"Local_label1"
Create Both
Expunge Both
SyncState *

#better to remove space in local name
Channel xxx-drafts
Master :xxx-remote:"[Xxx]/Sent Mail"
Slave :xxx-local:"[Xxx].SentMail"
Create Both
Expunge Both
SyncState *

Channel xxx-drafts
Master :xxx-remote:"[Xxx]/Drafts"
Slave :xxx-local:"[Xxx].Drafts"
Create Both
Expunge Both
SyncState *

#...

Group xxx
Channel xxx-mylabel2
Channel xxx-drafts
Channel xxx-inbox

# can repeat IMAPAccount

machine imap.xxx.com login myname@xxx.com password MYPASSWORD
machine smtp.xxx.com login myname@xxx.com password MYPASSWORD
machine imap.xxx.com login myname2@xxx.com password2 MYPASSWORD
machine smtp.xxx.com login myname2@xxx.com password2 MYPASSWORD