Emacs, une petite introduction

(server-start)

(use-package async
  :ensure t
  :init (dired-async-mode 1)
  :diminish)

(use-package gcmh
  :ensure t
  :demand t
  :init
  (setq gcmh-verbose             t
        gcmh-lows-cons-threshold #x800000
        gcmh-high-cons-threshold most-positive-fixnum
        gcmh-idle-delay          3600)
  :config
  (gcmh-mode)
  :diminish)

(setq vc-handled-backends nil)

(use-package autorevert
  :ensure t
  :diminish
  :config
  (setq auto-revert-verbose t)
  :hook (after-init-hook . global-auto-revert-mode))

  (setq global-auto-revert-mode t)

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

 ;; choice of the backup directory
(defconst my-backup-dir
  (expand-file-name (concat user-emacs-directory "backups")))

(setq make-backup-files t ;; make backup first time a file is saved
      version-control t   ;; number and keep versions of backups
      backup-by-copying t ;; and copy (don't clobber symlinks) them to...
      backup-directory-alist `(("." . ,my-backup-dir)) ;; ...here
      kept-new-versions 2
      kept-old-versions 5
      delete-old-versions t ;; don't ask about deleting old versions
      vc-make-backup-files 0 ;; don't backup files under version control (git/svn/etc.)
      ;;make-backup-files nil ;;No annoying "~file.txt"
      ;;auto-save-default nil ;;no auto saves to #file#
      auto-save-interval 180 ;; Auto save "file" to "#file#" every xxx (default 300)
      )

;; if no backup directory exists, then create it:
(if (not (file-exists-p my-backup-dir))
    (mkdir my-backup-dir t))

(fset 'yes-or-no-p 'y-or-n-p)

(setq user-full-name "Yves-Jean Daniel"
      user-mail-address "y-jean.daniel@uca.fr")

(setq history-delete-duplicates t)

(load-file "~/.emacs.d/mes_macros.el")

(defun config-visit ()
  (interactive)
  (find-file "~/.emacs.d/myinit.org"))
(global-set-key (kbd "C-c e") 'config-visit)

(defun config-reload ()
  "Reloads ~/.emacs.d/config.org at runtime"
  (interactive)
  (org-babel-load-file (expand-file-name "~/.emacs.d/myinit.org")))
(global-set-key (kbd "C-c r") 'config-reload)

  (use-package treemacs
  :ensure t
  :defer t
  :init
  (with-eval-after-load 'winum
    (define-key winum-keymap (kbd "M-0") #'treemacs-select-window))
  :config
  (progn
    (setq treemacs-collapse-dirs                 (if treemacs-python-executable 3 0)
          treemacs-deferred-git-apply-delay      0.5
          treemacs-directory-name-transformer    #'identity
          treemacs-display-in-side-window        t
          treemacs-eldoc-display                 t
          treemacs-file-event-delay              5000
          treemacs-file-extension-regex          treemacs-last-period-regex-value
          treemacs-file-follow-delay             0.2
          treemacs-file-name-transformer         #'identity
          treemacs-follow-after-init             t
          treemacs-git-command-pipe              ""
          treemacs-goto-tag-strategy             'refetch-index
          treemacs-indentation                   2
          treemacs-indentation-string            " "
          treemacs-is-never-other-window         nil
          treemacs-max-git-entries               5000
          treemacs-missing-project-action        'ask
          treemacs-move-forward-on-expand        nil
          treemacs-no-png-images                 nil
          treemacs-no-delete-other-windows       t
          treemacs-project-follow-cleanup        nil
          treemacs-persist-file                  (expand-file-name ".cache/treemacs-persist" user-emacs-directory)
          treemacs-position                      'left
          treemacs-recenter-distance             0.1
          treemacs-recenter-after-file-follow    nil
          treemacs-recenter-after-tag-follow     nil
          treemacs-recenter-after-project-jump   'always
          treemacs-recenter-after-project-expand 'on-distance
          treemacs-show-cursor                   nil
          treemacs-show-hidden-files             t
          treemacs-silent-filewatch              nil
          treemacs-silent-refresh                nil
          treemacs-sorting                       'alphabetic-asc
          treemacs-space-between-root-nodes      t
          treemacs-tag-follow-cleanup            t
          treemacs-tag-follow-delay              1.5
          treemacs-user-mode-line-format         nil
          treemacs-user-header-line-format       nil
          treemacs-width                         35)

    ;; The default width and height of the icons is 22 pixels. If you are
    ;; using a Hi-DPI display, uncomment this to double the icon size.
    ;;(treemacs-resize-icons 44)

    (treemacs-follow-mode t)
    (treemacs-filewatch-mode t)
    (treemacs-fringe-indicator-mode t)
    (pcase (cons (not (null (executable-find "git")))
                 (not (null treemacs-python-executable)))    
      (`(t . t)
       (treemacs-git-mode 'deferred))
      (`(t . _)
       (treemacs-git-mode 'simple))))
  :bind
  (:map global-map
        ("M-0"       . treemacs-select-window)
        ("C-* t 1"   . treemacs-delete-other-windows)
        ("C-* t t"   . treemacs)
        ("C-* t B"   . treemacs-bookmark)
        ("C-* t C-t" . treemacs-find-file)
        ("C-* t M-t" . treemacs-find-tag)))

(use-package treemacs-evil
  :after treemacs evil
  :ensure t)

(use-package treemacs-projectile
  :after treemacs projectile
  :ensure t)

(use-package treemacs-icons-dired
  :after treemacs dired
  :ensure t
  :config (treemacs-icons-dired-mode))

(use-package treemacs-magit
  :after treemacs magit
  :ensure t)

(use-package treemacs-persp
  :after treemacs persp-mode
  :ensure t
  :config (treemacs-set-scope-type 'Perspectives))

(use-package wgrep
  :ensure t)

(use-package wgrep-ag
  :ensure t)

(require 'wgrep-ag)

(setq-default cursor-type '(bar . 1)) ;; cursor is a bar/box/hollow/hbar

(blink-cursor-mode 1) 

 (use-package beacon
 :ensure
 :diminish
 :config
 (setq beacon-blink-delay 0.1)
 (setq beacon-blink-duration 0.25)
 (setq beacon-size 20))
(beacon-mode 1) ;; uncomment to activate

(use-package winner
  :ensure t
  :hook (after-init-hook . winner-mode)
  :bind ("<C-c right>" . winner-redo)
        ("<C-c left>" . winner-undo))
(winner-mode 1)

(use-package spaceline
  :ensure t
  :config
  (require 'spaceline-config)
  (setq spaceline-buffer-encoding-abbrev-p nil)
  (setq spaceline-line-column-p t)
  (setq spaceline-line-p nil)
  (setq powerline-default-separator (quote arrow))
  (spaceline-spacemacs-theme)
  (spaceline-helm-mode))
;; display time in powerline
(spaceline-define-segment datetime
  (shell-command-to-string "echo -n \"⏰  $(date '+%a %d %b %H:%M%p')\""))
(spaceline-spacemacs-theme 'datetime)

(use-package spaceline-all-the-icons 
  :ensure t
  :after spaceline
  :config (spaceline-all-the-icons-theme)
  (spaceline-all-the-icons--setup-anzu)
  )

(setq display-time-24hr-format t)
(setq display-time-format "%H:%M - %d %B %Y")
(display-time-mode 1)

(global-hl-line-mode t)
(set-face-background hl-line-face "#311") ;; with tangotango theme, the red color is too clingy

(use-package dashboard
  :ensure t
  :config
  (dashboard-setup-startup-hook)
  (setq dashboard-startup-banner "~/.emacs.d/img/sandman.jpeg") ;; vous
  ;; pouvez changer l'image...
  (setq dashboard-items '((recents  . 7)
                          (bookmarks . 5)
                          (agenda . 5)
                          (registers . 5)
                          (projects . 5)))
  (setq dashboard-banner-logo-title "Back already ?")
  (setq dashboard-set-heading-icons t)
  (setq dashboard-set-file-icons t)
  (setq dashboard-set-navigator t)
  )

;; (global-linum-mode 1)

(add-hook 'prog-mode-hook #'linum-mode) 

;; Chargement thème tangotango
(use-package tangotango-theme
  :ensure t
  :config (load-theme 'tangotango t)
  :diminish)

(use-package spacegray-theme :defer t)
(use-package doom-themes
  :ensure t
  :config
  ;; Global settings (defaults)
  (setq doom-themes-enable-bold t    ; if nil, bold is universally disabled
        doom-themes-enable-italic t) ; if nil, italics is universally disabled
  (load-theme 'doom-dracula t)

  ;; Enable flashing mode-line on errors
  (doom-themes-visual-bell-config)
  ;; Enable custom neotree theme (all-the-icons must be installed!)
  (doom-themes-neotree-config)
  ;; or for treemacs users
  (setq doom-themes-treemacs-theme "doom-atom") ; use "doom-colors" for less minimal icon theme
  (doom-themes-treemacs-config)
  ;; Corrects (and improves) org-mode's native fontification.
  (doom-themes-org-config))

(unless (member "all-the-icons" (font-family-list))
  (all-the-icons-install-fonts t))

(use-package all-the-icons 
:ensure t
:defer 0.5)
 (use-package all-the-icons-ivy
  :ensure t
  :after (all-the-icons ivy)
  :custom (all-the-icons-ivy-buffer-commands '(ivy-switch-buffer-other-window ivy-switch-buffer))
  :config
  (add-to-list 'all-the-icons-ivy-file-commands 'counsel-dired-jump)
  (add-to-list 'all-the-icons-ivy-file-commands 'counsel-find-library)
  (all-the-icons-ivy-setup))

(use-package all-the-icons-dired
  :ensure t)

(add-hook 'dired-mode-hook 'all-the-icons-dired-mode)

(delete-selection-mode t)

(use-package which-key
  :ensure t
  :config (which-key-mode)
  :diminish)  

(use-package expand-region
  :ensure t
  :bind ("C-q" . er/expand-region)
  :diminish)

(use-package multiple-cursors
 :ensure t
 :bind (:map global-map
       ("C->" . mc/mark-next-like-this)
       ("C-<" . mc/mark-previous-like-this)
       ("C-c C-," . mc/mark-all-like-this)
       ("C-S-<mouse-1>" . mc/add-cursor-on-click)))
(provide 'init-multiple-cursors)

(use-package hungry-delete
  :ensure t
  :config
    (global-hungry-delete-mode)
  :diminish)

(setq kill-ring-max 100) ;; passer la taille du kill-ring à 100 (par défaut 60)
(use-package popup-kill-ring
  :ensure t
  :bind ("M-y" . popup-kill-ring)
  :diminish)

(use-package yasnippet ;; le moteur
  :ensure t
  :config
    (use-package yasnippet-snippets ;; un pack de snippets
      :ensure t
      :diminish)
    (yas-reload-all)
    (yas-global-mode 1) ;; activé partout
  :diminish) 

(setq-default auto-fill-function 'do-auto-fill)
(setq-default fill-column 80)

(global-set-key "\M-k" '(lambda () (interactive) (kill-line 0)) )

(use-package counsel
  :ensure t
  :diminish)

(use-package swiper
  :ensure t
  :config (progn

            (ivy-mode 1)
            (setq ivy-use-virtual-buffers t)
            (setq enable-recursive-minibuffers t)
            ;; enable this if you want `swiper' to use it
            ;; (setq search-default-mode #'char-fold-to-regexp)
            (global-set-key "\C-s" 'swiper)
            (global-set-key (kbd "C-c C-r") 'ivy-resume)
            (global-set-key (kbd "M-x") 'counsel-M-x)
            (global-set-key (kbd "C-x C-f") 'counsel-find-file)
            (global-set-key (kbd "<f6>") 'ivy-resume)
            (global-set-key (kbd "<f1> f") 'counsel-describe-function)
            (global-set-key (kbd "<f1> v") 'counsel-describe-variable)
            (global-set-key (kbd "<f1> l") 'counsel-find-library)
            (global-set-key (kbd "<f2> i") 'counsel-info-lookup-symbol)
            (global-set-key (kbd "<f2> u") 'counsel-unicode-char)
            (global-set-key (kbd "C-c g") 'counsel-git)
            (global-set-key (kbd "C-c j") 'counsel-git-grep)
            (global-set-key (kbd "C-c k") 'counsel-ag)
            (global-set-key (kbd "C-x l") 'counsel-locate)
            (global-set-key (kbd "C-S-o") 'counsel-rhythmbox)
            (define-key minibuffer-local-map (kbd "C-r")
            'counsel-minibuffer-history)
   :diminish))

(use-package avy
  :ensure t
  :bind ("M-s" . avy-goto-char-timer)
  :diminish)

  ;;;  Jonas.Jarnestrom<at>ki.ericsson.se A smarter               
  ;;;  find-tag that automagically reruns etags when it cant find a               
  ;;;  requested item and then makes a new try to locate it.                      
  ;;;  Fri Mar 15 09:52:14 2002    
(defadvice find-tag (around refresh-etags activate)
  "Rerun etags and reload tags if tag not found and redo find-tag.              
   If buffer is modified, ask about save before running etags."
  (let ((extension (file-name-extension (buffer-file-name))))
    (condition-case err
        ad-do-it
      (error (and (buffer-modified-p)
                  (not (ding))
                  (y-or-n-p "Buffer is modified, save it? ")
                  (save-buffer))
             (er-refresh-etags extension)
             ad-do-it))))
(defun er-refresh-etags (&optional extension)
  "Run etags on all peer files in current dir and reload them silently."
  (interactive)
  (shell-command (format "etags *.%s" (or extension "el")))
  (let ((tags-revert-without-query t))  ; don't query, revert silently          
    (visit-tags-table default-directory nil)))

(setq ispell-local-dictionary-alist- 
      '(("francais" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "fr") nil utf-8)
        ("en_US" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_US") nil utf-8)
        ))
(setq ispell-program-name "hunspell"          ; Use hunspell to correct mistakes
      ispell-dictionary   "francais")

(defun switch-dictionary-fr-en ()
  "Switch french and english dictionaries."
  (interactive)
  (let* ((dict ispell-current-dictionary)
         (new (if (string= dict "francais") "en_US"
                   "francais")))
    (ispell-change-dictionary new)
    (message "Switched dictionary from %s to %s" dict new)))

(global-set-key (kbd "C-c d") 'switch-dictionary-fr-en)

;; (add-hook 'prog-mode-hook 'flyspell-prog-mode) ;; if you write text with a
;; lot of text, it is possible to activte it, the problem is that it suggests errors
;; when you put code inside ""
(global-set-key (kbd "C-c f") 'flyspell-check-previous-highlighted-word)

;;-------------
;; Text mode
;;-------------
(add-hook 'text-mode-hook 'flyspell-mode)
(add-hook 'prog-mode-hook 'flyspell-prog-mode)

;; Highlight BUG FIXME TODO NOTE keywords in the source code.
(add-hook 'find-file-hook
          (lambda()
            (highlight-phrase "\\(BUG\\|FIXME\\|TODO\\|NOTE\\):")))

(org-babel-do-load-languages
   'org-babel-load-languages
   '((ditaa      . t)
     (C          . t)
     (dot        . t)
     (emacs-lisp . t)
     (scheme     . t)
     (gnuplot    . t)
     (haskell    . t)
     (latex      . t)
     (js         . t)
     (ledger     . t)
     (matlab     . t)
     (ocaml      . t)
     (octave     . t)
     (plantuml   . t)
     (python     . t)
     (R          . t)
     (ruby       . t)
     (screen     . nil)
     (scheme     . t)
     (shell      . t)
     (sql        . t)
     (sqlite     . t)))
(setq org-babel-python-command "python3")

(add-hook 'org-mode-hook
          (lambda ()
            (add-hook 'after-save-hook
                      (lambda ()
                         (org-babel-tangle))
                      nil
                      'make-it-local)))

(setq org-export-in-background t)

(setq org-confirm-babel-evaluate nil)

(use-package org-bullets
    :ensure t
    :config  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
    :diminish)
;; (setq org-bullets-bullet-list '("■" "◆" "▲" "▶")) ;; If you want to change
;;    the symbols, but I like the defaults

(setq org-ellipsis " ⬎")

(setq org-src-tab-acts-natively t)

(setq org-confirm-babel-evaluate nil)

(add-hook 'org-mode-hook
          '(lambda ()
             (visual-line-mode 1)))

(global-set-key
    (kbd "C-c t")
    (defhydra hydra-global-org (:color blue)
      "Org"
      ("t" org-timer-start "Start Timer")
      ("s" org-timer-stop "Stop Timer")
      ("r" org-timer-set-timer "Set Timer") ; This one requires you be in an orgmode doc, as it sets the timer for the header
      ("p" org-timer "Print Timer") ; output timer value to buffer
      ("w" (org-clock-in '(4)) "Clock-In") ; used with (org-clock-persistence-insinuate) (setq org-clock-persist t)
      ("o" org-clock-out "Clock-Out") ; you might also want (setq org-log-note-clock-out t)
      ("j" org-clock-goto "Clock Goto") ; global visit the clocked task
      ("c" org-capture "Capture") ; Don't forget to define the captures you want http://orgmode.org/manual/Capture.html
            ("l" org-capture-goto-last-stored "Last Capture"))
    )

(eval-after-load 'org
  (add-hook 'org-babel-after-execute-hook 'org-redisplay-inline-images))

(use-package eaf
    :load-path "~/.emacs.d/site-lisp/emacs-application-framework" ; Set to "/usr/share/emacs/site-lisp/eaf" if installed from AUR
    :custom
    ; See
    ; https://github.com/emacs-eaf/emacs-application-framework/wiki/Customization
    (eaf-browser-continue-where-left-off t)
    (eaf-browser-enable-adblocker t)
    (browse-url-browser-function 'eaf-open-browser)
    :config
    (defalias 'browse-web #'eaf-open-browser))
  ;;  (eaf-bind-key scroll_up "C-n" eaf-pdf-viewer-keybinding)
  ;;  (eaf-bind-key scroll_down "C-p" eaf-pdf-viewer-keybinding)
  ;;  (eaf-bind-key take_photo "p" eaf-camera-keybinding)
  ;;  (eaf-bind-key nil "M-q" eaf-browser-keybinding)) ;; unbind, see more in the Wiki

  (add-to-list 'load-path "~/.emacs.d/site-lisp/eaf-browser/")

  (require 'eaf-browser)

  (add-to-list 'load-path "~/.emacs.d/site-lisp/eaf-browser/")

  (require 'eaf-browser)
(eaf-setq eaf-browser-enable-adblocker "true")

(add-to-list 'load-path "~/.emacs.d/site-lisp/eaf-pdf-viewer/")
(require 'eaf-pdf-viewer)

(require 'eaf-org-previewer)
(require 'eaf-airshare)
(require 'eaf-mindmap)

(require 'eaf-system-monitor)
(require 'eaf-netease-cloud-music)
(require 'eaf-terminal)
(require 'eaf-demo)
(require 'eaf-file-browser)
(require 'eaf-vue-demo)
(require 'eaf-jupyter)
(require 'eaf-file-sender)
(require 'eaf-browser)
(require 'eaf-file-manager)
(require 'eaf-image-viewer)
(require 'eaf-music-player)
(require 'eaf-markdown-previewer)
(require 'eaf-camera)
(require 'eaf-video-player)

   (ivy-mode 1)
   (setq ivy-use-virtual-buffers t)
   (global-set-key (kbd "C-c C-r") 'ivy-resume)
   (global-set-key (kbd "<f6>") 'ivy-resume)
;;Plus cool completion approximative dans le buffer
(setq ido-enable-flex-matching t)
(ido-mode 1)

(use-package company
  :ensure t
  :init (global-company-mode)
  :config
    (setq company-idle-delay 0)
    (setq company-minimum-prefix-length 3)
  :diminish company-mode)

(with-eval-after-load 'company
  (define-key company-active-map (kbd "M-n") nil)
  (define-key company-active-map (kbd "M-p") nil)
  (define-key company-active-map (kbd "C-n") #'company-select-next)
  (define-key company-active-map (kbd "C-p") #'company-select-previous)
  (define-key company-active-map (kbd "SPC") #'company-abort))

  (use-package helm
  :ensure t
  :bind
  ("C-x C-f" . 'helm-find-files)
  ("C-x C-b" . 'helm-buffers-list)
  ("M-x" . 'helm-M-x)
  :config
  (defun my/helm-hide-minibuffer ()
    (when (with-helm-buffer helm-echo-input-in-header-line)
      (let ((ov (make-overlay (point-min) (point-max) nil nil t)))
        (overlay-put ov 'window (selected-window))
        (overlay-put ov 'face
                     (let ((bg-color (face-background 'default nil)))
                       `(:background ,bg-color :foreground ,bg-color)))
        (setq-local cursor-type nil))))
  (add-hook 'helm-minibuffer-set-up-hook 'my/helm-hide-minibuffer)
  (setq helm-autoresize-max-height 0
        helm-autoresize-min-height 40
        helm-M-x-fuzzy-match t
        helm-buffers-fuzzy-matching t
        helm-recentf-fuzzy-match t
        helm-semantic-fuzzy-match t
        helm-imenu-fuzzy-match t
        helm-split-window-in-side-p nil
        helm-move-to-line-cycle-in-source nil
        helm-ff-search-library-in-sexp t
        helm-scroll-amount 8 
        helm-echo-input-in-header-line t)
  :init
  (helm-mode 1))

(require 'helm-config)    
(helm-autoresize-mode 1)
(define-key helm-find-files-map (kbd "C-b") 'helm-find-files-up-one-level)
(define-key helm-find-files-map (kbd "C-f") 'helm-execute-persistent-action)

(add-hook 'prog-mode-hook 'subword-mode)

(use-package origami
  :ensure t
  :demand
  :config
  (define-prefix-command 'origami-mode-map)
  (global-set-key (kbd "C-x C-z") 'origami-mode-map)
  (global-origami-mode)
  :bind
  (:map origami-mode-map
        ("o" . origami-open-node)
        ("O" . origami-open-node-recursively)
        ("c" . origami-close-node)
        ("C" . origami-close-node-recursively)
        ("a" . origami-toggle-node)
        ("A" . origami-recursively-toggle-node)
        ("R" . origami-open-all-nodes)
        ("M" . origami-close-all-nodes)
        ("v" . origami-show-only-node)
        ("k" . origami-previous-fold)
        ("j" . origami-forward-fold)
        ("x" . origami-reset))
  :diminish)

;; Origami mode keys
(define-key global-map (kbd "C-x C-z") 'origami-mode-map)
(define-prefix-command 'origami-mode-map)
(define-key origami-mode-map (kbd "o") 'origami-open-node)
(define-key origami-mode-map (kbd "O") 'origami-open-node-recursively)
(define-key origami-mode-map (kbd "c") 'origami-close-node)
(define-key origami-mode-map (kbd "C") 'origami-close-node-recursively)
(define-key origami-mode-map (kbd "a") 'origami-toggle-node)
(define-key origami-mode-map (kbd "A") 'origami-recursively-toggle-node)
(define-key origami-mode-map (kbd "R") 'origami-open-all-nodes)
(define-key origami-mode-map (kbd "M") 'origami-close-all-nodes)
(define-key origami-mode-map (kbd "v") 'origami-show-only-node)
(define-key origami-mode-map (kbd "k") 'origami-previous-fold)
(define-key origami-mode-map (kbd "j") 'origami-forward-fold)
(define-key origami-mode-map (kbd "x") 'origami-reset)

;; Set up some global minor modes
(global-origami-mode t)
(show-paren-mode t)
(global-prettify-symbols-mode t)

(use-package clang-format+
  :ensure t)

(add-hook 'c-mode-common-hook #'clang-format+-mode)
(add-hook 'c-mode-common-hook
          (lambda ()
            (local-set-key (kbd "C-x <C-tab>") 'clang-format-region)))

(use-package flycheck
  :ensure t
  :init
  (global-flycheck-mode t)
  (set-face-attribute 'flycheck-error nil :foreground "black" :background
                      "#EE4400")
  (set-face-attribute 'flycheck-warning nil :foreground "black" :background
                      "#EE9900")
  (set-face-attribute 'flycheck-info nil :foreground "black" :background
                      "#008800")
  :diminish)

(add-hook 'c++-mode-hook 'yas-minor-mode)
(add-hook 'c-mode-hook 'yas-minor-mode)

(use-package flycheck-clang-analyzer
  :ensure t
  :config
  (with-eval-after-load 'flycheck
    (require 'flycheck-clang-analyzer)
     (flycheck-clang-analyzer-setup)))

(with-eval-after-load 'company
  (add-hook 'c++-mode-hook 'company-mode)
  (add-hook 'c-mode-hook 'company-mode))

(use-package company-c-headers
  :ensure t)

(use-package company-irony
  :ensure t
  :config
  (setq company-backends '((company-c-headers
                            company-dabbrev-code
                            company-irony))))

(use-package irony
  :ensure t
  :config
  (add-hook 'c++-mode-hook 'irony-mode)
  (add-hook 'c-mode-hook 'irony-mode)
  (add-hook 'irony-mode-hook 'irony-cdb-autosetup-compile-options))

(use-package ggtags
:ensure t
:config 
(add-hook 'c-mode-common-hook
          (lambda ()
            (when (derived-mode-p 'c-mode 'c++-mode 'java-mode)
              (ggtags-mode 1))))
)

(add-hook 'c-mode-common-hook
          (lambda()
            (local-set-key (kbd "M-<right>") 'hs-show-block)
            (local-set-key (kbd "M-<left>")  'hs-hide-block)
            (local-set-key (kbd "M-<up>")    'hs-hide-all)
            (local-set-key (kbd "M-<down>")  'hs-show-all)

            ;;hide/show code-block
            (hs-minor-mode t)))

;; Paredit pour la gestion des parenthéses en lisp
;; setup paredit
(use-package paredit
  :ensure t
  :init
  (dolist (hook '(emacs-lisp-mode-hook lisp-mode-hook clojure-mode-hook scheme-mode-hook))
    (add-hook hook 'paredit-mode))
  :diminish paredit-mode)

(add-hook 'python-mode-hook 'yas-minor-mode)
(add-hook 'python-mode-hook 'flycheck-mode)

(with-eval-after-load 'company
    (add-hook 'python-mode-hook 'company-mode))

(use-package company-jedi
  :ensure t
  :config
    (require 'company)
    (add-to-list 'company-backends 'company-jedi))

(defun python-mode-company-init ()
  (setq-local company-backends '((company-jedi
                                  company-etags
                                  company-dabbrev-code))))

(use-package company-jedi
  :ensure t
  :config
    (require 'company)
    (add-hook 'python-mode-hook 'python-mode-company-init))

(use-package virtualenvwrapper
          :ensure t
          :config
          (venv-initialize-interactive-shells)
          (venv-initialize-eshell))

(setq python-shell-interpreter "python3")
(setq python-shell-interpreter-args "-m IPython --simple-prompt -i") 
(setq flycheck-python-pycompile-executable "python3")

(add-hook 'shell-mode-hook 'yas-minor-mode)
(add-hook 'shell-mode-hook 'flycheck-mode)
(add-hook 'shell-mode-hook 'company-mode)

(defun shell-mode-company-init ()
  (setq-local company-backends '((company-shell
                                  company-shell-env
                                  company-etags
                                  company-dabbrev-code))))

(use-package company-shell
  :ensure t
  :config
    (require 'company)
    (add-hook 'shell-mode-hook 'shell-mode-company-init))

(use-package css-mode
  :ensure t
  :custom (css-indent-offset 2))

(use-package scss-mode
  :ensure t
  :preface
  (defun me/scss-set-comment-style ()
    (setq-local comment-end "")
    (setq-local comment-start "//"))
  :mode ("\\.sass\\'" "\\.scss\\'")
  :hook (scss-mode . me/scss-set-comment-style))

(add-hook 'emacs-lisp-mode-hook 'eldoc-mode)
(add-hook 'emacs-lisp-mode-hook 'yas-minor-mode)
(add-hook 'emacs-lisp-mode-hook 'company-mode)

(use-package slime
  :ensure t
  :config
  (setq inferior-lisp-program "/usr/bin/sbcl")
  (setq slime-contribs '(slime-fancy)))

(use-package slime-company
  :ensure t
  :init
    (require 'company)
    (slime-setup '(slime-fancy slime-company)))

(use-package gnuplot
  :ensure t)

(use-package graphviz-dot-mode
  :ensure t)
(use-package company-graphviz-dot)

(setq org-ditaa-jar-path "/usr/bin/ditaa")

(use-package markdown-mode
  :ensure
  :preface
  (defun my/markdown-set-ongoing-hydra-body ()
    (setq my/ongoing-hydra-body #'hydra-markdown/body))
  :mode
  ("INSTALL\\'"
   "CONTRIBUTORS\\'"
   "LICENSE\\'"
   "README\\'"
   "\\.markdown\\'"
   "\\.md\\'")
  :hook
  (markdown-mode . my/markdown-set-ongoing-hydra-body)
  :custom
  (markdown-asymmetric-header t)
  (markdown-split-window-direction 'right)
  :config
  (unbind-key "M-<down>" markdown-mode-map)
  (unbind-key "M-<up>" markdown-mode-map))

;;  (use-package bison-mode :ensure t)

;; (require 'flex)
;;
;; (add-to-list 'auto-mode-alist '("\\.l$" . flex-mode))
;; (autoload 'flex-mode "flex")

(use-package wttrin
  :ensure t
  :commands (wttrin)
  :init
  (setq wttrin-default-cities '("Aydat" "Clermont-Ferrand" "Hanoi")))

(use-package proced
:commands proced
:config
(setq proced-auto-update-flag t)
(setq proced-auto-update-interval 1)
(setq proced-descend t)
(setq proced-filter 'user))

(use-package vimgolf
  :ensure t)

(use-package nov
  :ensure t
  :mode ("\\.epub\\'" . nov-mode)
  :config (progn
            (defun my-nov-font-setup ()
              (face-remap-add-relative 'variable-pitch
                                       :family "Gentium Book Basic"
                                       :height 1.0))
            (add-hook 'nov-mode-hook 'my-nov-font-setup)

            (setq nov-text-width 80)

            (defun my-nov-window-configuration-change-hook ()
              (my-nov-post-html-render-hook)
              (remove-hook 'window-configuration-change-hook
                           'my-nov-window-configuration-change-hook
                           t))

            (defun my-nov-post-html-render-hook ()
              (if (get-buffer-window)
                  (let ((max-width (pj-line-width))
                        buffer-read-only)
                    (save-excursion
                      (goto-char (point-min))
                      (while (not (eobp))
                        (when (not (looking-at "^[[:space:]]*$"))
                          (goto-char (line-end-position))
                          (when (> (shr-pixel-column) max-width)
                            (goto-char (line-beginning-position))
                            ))
                        (forward-line 1))))

                (add-hook 'window-configuration-change-hook
                          'my-nov-window-configuration-change-hook
                          nil t)))

            (add-hook 'nov-post-html-render-hook 'my-nov-post-html-render-hook)))

#include <stdio.h>
int main(){
  puts("Hello multiverse");
  return 0;
}

#+name: toto
#+BEGIN_SRC C :results silent
  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>

  int main(){
    srand(time(NULL));
    printf("%d", rand()%100);
    return 0;
  }

#+call: toto() :results table append

#+name: ex1_code 
#+header: :var data1="Thanks" 
#+header: :var data2="for all the fish"
#+begin_src C 
  #include <stdio.h>

  int main(){
    printf("%s %s\n",data1, data2);
    return 0;
  }
$ $#+end_src

#+call: ex1_code(data1="So", data2="long")

#+name: ex1_data
 | Le     |
 | Cheval |

#+call: ex1_code(data1=ex1_data[0,0], data2=ex1_data[1,0])

#+name: ex2_data
| Le    | cheval |     |
| blanc | de     | Bob |

#+name: ex2_code 
#+header: :var data=ex1_data
#+header: :results raw
#+begin_src C 
  #include <stdio.h>

  int main(){
    for(int i = data_rows-1 ; i>=0 ; --i){
      for(int j = data_cols-1 ; j>=0 ; --j){
        printf("|\ %s ",data[i][j]);
      }
      printf("\n");
    }
    return 0;
  }
$ $#+end_src
#+name: hello

#+call: ex2_code(data=ex2_data)
#+name: out

#+call: ex2_code(data=out)

(eval-after-load 'org
  (add-hook 'org-babel-after-execute-hook 'org-redisplay-inline-images))

#+STARTUP: inlineimages  

  strict digraph {
    a [shape="ellipse" style="filled" fillcolor="#1f77b4"]
    b [shape="polygon" style="filled" fillcolor="#ff7f0e"]
    a -> b [fillcolor="#a6cee3" color="#1f78b4"]
    Père [ shape=ellipse style="filled" fillcolor="#FF44cc"]
    Mère [ shape=octagon]
    Frère [ style="radial, solid" color="#c22727" fillcolor="#99cb0b" shape=ellipse]
    Père -> b
    Frère -> Père
    n6
    n6 -> a

    Frère -> b [ style=dashed color="#824848" fillcolor="#a361bb"]
    n6 -> n6 [ style=dashed color="#824848" fillcolor="#a361bb"]
    a -> n6 [ style="tapered, solid" color="#824848" fillcolor="#a361bb"]
    n6 -> Mère [ style="dashed"]
    Mère -> Père
    Frère -> Pierre
    n6 -> Frère
}

/------------------------------\      +-------------------+
|                              |      |  {d}       cGRE   |
|                              |      |                   |
|                              |      | Help   +--------+ |
|        Hello world           +----->|        |  cYEL  | |
|                              |      |        +--------+ |
|                 cBLU         |      +----------+--------+
|                              |        |        |  
\-------------+----------------/        *----+   |  
              ^                         |    |   |  
              |                         v    +-->*--+  
              |                       +---+---+     |
              |                       | {s}   |     |
              v                       | cPNK  +-----+   
+-------------+-----------------+     | Me... |
|  {io}                         |     +---+---+   /--\
|                     cRED      |         |       |  | 
|          Patatoes             +<-----+  :   /---*  *---\
|                               |      |  |   |          +
|                               |      |  |   ++         |
+-------------------------------+      +--+    \---------+

def hello():
  print("hello World")

hello()

print("ici est ailleurs")

int main(){
  puts("Salut les copains !");
  return 0;
} 

gcc -Wall -Wextra -o hello hello.c
./hello

#include "stdio.h"
#include "stdlib.h"


int main(int argc, char ** argv){
  (void) argc;
  (void) argv;
  srand(143); 

  int i, k;

  for(i = 0 ; i < 10 ; ++i){
    for (k = 0 ; k < rand()%5+1; ++k){
      printf("%d -> %d\n", i, rand()%10);
    }
  }


  return 0; 
}

strict digraph {
 $monGraph
}

#include <stdio.h>
#include <string.h>

long max(long u, long v){
  return u<v?v:u;
}

int main(){
  long
    best_lg = 1,
    before_lg = 0,
    after_lg = 0,
    lg;

  char b[1001];

  scanf("%[^\n]", b);
  lg = strlen(b);

  b[lg++] = '0';
  b[lg] = '\0';

  for(int i = 0 ; i < lg ; ++i){
    if(b[i] == '1'){
      ++ after_lg;
    } else{
      best_lg = max(best_lg,after_lg + before_lg +1);
      before_lg = after_lg;
      after_lg = 0;
    }
  }
  printf("%ld\n", best_lg);
  return 0;
}

gcc -Wall -Wextra $file_in -o $file_out 

import os

f = open("test.in", "w")
for u in test_in:
  f.write(u) 
f.close()

stream = os.popen(exe+" <test.in")
output = stream.read()

if output==test_out:
   print("Test réussi")
else:
   print("Echec du test" )  
   print("obtenu :\t", output)
   print("désiré :\t", test_out)