#+STARTUP: overview 
#+PROPERTY: header-args :comments yes :results silent
* repos
#+BEGIN_SRC emacs-lisp
(add-to-list 'package-archives '("org" . "https://orgmode.org/elpa/") t)
#+END_SRC
* interface tweaks
#+BEGIN_SRC emacs-lisp
(setq inhibit-startup-message t)
(tool-bar-mode -1)
(fset 'yes-or-no-p 'y-or-n-p)
(global-set-key (kbd "<f5>") 'revert-buffer)
#+END_SRC

* try
#+BEGIN_SRC emacs-lisp
(use-package try
	:ensure t)
#+END_SRC

* posframe

#+BEGIN_SRC emacs-lisp
(use-package posframe :ensure t)
#+END_SRC
* which key
  Brings up some help
  #+BEGIN_SRC emacs-lisp
    (use-package which-key
      :ensure t 
      :config
      (which-key-mode))

#+END_SRC

* Org mode


  Org bullets makes things look pretty
  #+BEGIN_SRC emacs-lisp

    (use-package org 
      :ensure t
      :pin org)

    (setenv "BROWSER" "firefox")
    (use-package org-bullets
      :ensure t
      :config
      (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))
    (custom-set-variables
     '(org-directory "~/Sync/orgfiles")
     '(org-default-notes-file (concat org-directory "/notes.org"))
     '(org-export-html-postamble nil)
     '(org-hide-leading-stars t)
     '(org-startup-folded (quote overview))
     '(org-startup-indented t)
     '(org-confirm-babel-evaluate nil)
     '(org-src-fontify-natively t)
     )

    (setq org-file-apps
          (append '(
                    ("\\.pdf\\'" . "evince %s")
                    ("\\.x?html?\\'" . "/usr/bin/firefox %s")
                    ) org-file-apps ))

    (global-set-key "\C-ca" 'org-agenda)
    (setq org-agenda-start-on-weekday nil)
    (setq org-agenda-custom-commands
          '(("c" "Simple agenda view"
             ((agenda "")
              (alltodo "")))))

    (global-set-key (kbd "C-c c") 'org-capture)

    (setq org-agenda-files (list "~/Sync/orgfiles/gcal.org"
                                 "~/Sync/orgfiles/soe-cal.org"
                                 "~/Sync/orgfiles/i.org"
                                 "~/Sync/orgfiles/schedule.org"))
    (setq org-capture-templates
          '(("a" "Appointment" entry (file  "~/Sync/orgfiles/gcal.org" )
             "* %?\n\n%^T\n\n:PROPERTIES:\n\n:END:\n\n")
            ("l" "Link" entry (file+headline "~/Sync/orgfiles/links.org" "Links")
             "* %? %^L %^g \n%T" :prepend t)
            ("b" "Blog idea" entry (file+headline "~/Sync/orgfiles/i.org" "Blog Topics:")
             "* %?\n%T" :prepend t)
            ("t" "To Do Item" entry (file+headline "~/Sync/orgfiles/i.org" "To Do and Notes")
             "* TODO %?\n%u" :prepend t)
            ("m" "Mail To Do" entry (file+headline "~/Sync/orgfiles/i.org" "To Do and Notes")
             "* TODO %a\n %?" :prepend t)
            ("g" "GMail To Do" entry (file+headline "~/Sync/orgfiles/i.org" "To Do and Notes")
             "* TODO %^L\n %?" :prepend t)
            ("n" "Note" entry (file+headline "~/Sync/orgfiles/i.org" "Notes")
             "* %u %? " :prepend t)
            ))
  

    (defadvice org-capture-finalize 
        (after delete-capture-frame activate)  
      "Advise capture-finalize to close the frame"  
      (if (equal "capture" (frame-parameter nil 'name))  
          (delete-frame)))

    (defadvice org-capture-destroy 
        (after delete-capture-frame activate)  
      "Advise capture-destroy to close the frame"  
      (if (equal "capture" (frame-parameter nil 'name))  
          (delete-frame)))  

    (use-package noflet
      :ensure t )
    (defun make-capture-frame ()
      "Create a new frame and run org-capture."
      (interactive)
      (make-frame '((name . "capture")))
      (select-frame-by-name "capture")
      (delete-other-windows)
      (noflet ((switch-to-buffer-other-window (buf) (switch-to-buffer buf)))
        (org-capture)))
;; (require 'ox-beamer)
;; for inserting inactive dates
    (define-key org-mode-map (kbd "C-c >") (lambda () (interactive (org-time-stamp-inactive))))

    (use-package htmlize :ensure t)

    (setq org-ditaa-jar-path "/usr/share/ditaa/ditaa.jar")

  #+END_SRC

  #+RESULTS:
  : make-capture-frame

* Ace windows for easy window switching
  #+BEGIN_SRC emacs-lisp
  (use-package ace-window
  :ensure t
  :init
  (progn
  (setq aw-scope 'global) ;; was frame
  (global-set-key (kbd "C-x O") 'other-frame)
    (global-set-key [remap other-window] 'ace-window)
    (custom-set-faces
     '(aw-leading-char-face
       ((t (:inherit ace-jump-face-foreground :height 3.0))))) 
    ))
  #+END_SRC

  #+RESULTS:

* Swiper / Ivy / Counsel
  Swiper gives us a really efficient incremental search with regular expressions
  and Ivy / Counsel replace a lot of ido or helms completion functionality
  #+BEGIN_SRC emacs-lisp
  



   (use-package counsel
:ensure t
  :bind
  (("M-y" . counsel-yank-pop)
   :map ivy-minibuffer-map
   ("M-y" . ivy-next-line)))




  (use-package ivy
  :ensure t
  :diminish (ivy-mode)
  :bind (("C-x b" . ivy-switch-buffer))
  :config
  (ivy-mode 1)
  (setq ivy-use-virtual-buffers t)
  (setq ivy-count-format "%d/%d ")
  (setq ivy-display-style 'fancy))


  (use-package swiper
  :ensure t
  :bind (("C-s" . swiper-isearch)
	 ("C-r" . swiper-isearch)
	 ("C-c C-r" . ivy-resume)
	 ("M-x" . counsel-M-x)
	 ("C-x C-f" . counsel-find-file))
  :config
  (progn
    (ivy-mode 1)
    (setq ivy-use-virtual-buffers t)
    (setq ivy-display-style 'fancy)
    (define-key read-expression-map (kbd "C-r") 'counsel-expression-history)
    ))
  #+END_SRC

* Avy - navigate by searching for a letter on the screen and jumping to it
  See https://github.com/abo-abo/avy for more info
  #+BEGIN_SRC emacs-lisp
  (use-package avy
  :ensure t
  :bind ("M-s" . avy-goto-word-1)) ;; changed from char as per jcs
  #+END_SRC

* Company
#+BEGIN_SRC emacs-lisp
(use-package company
:ensure t
:config
(setq company-idle-delay 0)
(setq company-minimum-prefix-length 3)

(global-company-mode t)
)


(defun my/python-mode-hook ()
  (add-to-list 'company-backends 'company-jedi))

(add-hook 'python-mode-hook 'my/python-mode-hook)
(use-package company-jedi
    :ensure t
    :config
    (add-hook 'python-mode-hook 'jedi:setup)
       )

(defun my/python-mode-hook ()
  (add-to-list 'company-backends 'company-jedi))

(add-hook 'python-mode-hook 'my/python-mode-hook)

;; company box mode
;(use-package company-box
;:ensure t
;  :hook (company-mode . company-box-mode)) 


#+END_SRC

#+RESULTS:
* C++
#+BEGIN_SRC emacs-lisp
(use-package company-irony
:ensure t
:config 
(add-to-list 'company-backends '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 irony-eldoc
:ensure t
:config
(add-hook 'irony-mode-hook #'irony-eldoc))


#+END_SRC
* Themes and modeline
  #+BEGIN_SRC emacs-lisp 

    (use-package color-theme-modern
      :ensure t)
    (use-package zenburn-theme
      :ensure t
    
      )

        (use-package base16-theme
        :ensure t
        )
        (use-package moe-theme
        :ensure t)


        (use-package alect-themes
        :ensure t)

    (use-package zerodark-theme
        :ensure t)

    (use-package faff-theme
      :ensure t)
    (use-package poet-theme
      :ensure t)
    (use-package tao-theme
      :ensure t)
    (use-package doom-themes
      :ensure t)
    (use-package doom-modeline
      :ensure t)
(require 'doom-modeline)
(doom-modeline-init)
;(load-theme 'faff t)
(load-theme 'faff t)
  #+END_SRC



* Reveal.js
  #+BEGIN_SRC emacs-lisp  :tangle no
  (use-package ox-reveal
  :ensure t
  :config
    (require 'ox-reveal)
    (setq org-reveal-root "http://cdn.jsdelivr.net/reveal.js/3.0.0/")
    (setq org-reveal-mathjax t)
)
    (use-package htmlize
    :ensure t)
  #+END_SRC

  #+RESULTS:
  : t
  
* Flycheck
  #+BEGIN_SRC emacs-lisp
    (use-package flycheck
      :ensure t
      :init
      (global-flycheck-mode t))

  #+END_SRC
* Python
  #+BEGIN_SRC emacs-lisp

        (setq py-python-command "python3")
        (setq python-shell-interpreter "python3")
 

            (use-package elpy
            :ensure t
:custom (elpy-rpc-backend "jedi")
            :config 

            (elpy-enable)
            
)

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

  #+END_SRC

  #+RESULTS:
  : t

* Yasnippet
  #+BEGIN_SRC emacs-lisp
    (use-package yasnippet
      :ensure t
      :init
        (yas-global-mode 1))

;    (use-package yasnippet-snippets
;      :ensure t)
  #+END_SRC

  #+RESULTS:

* Undo Tree
  #+BEGIN_SRC emacs-lisp :tangle no
    (use-package undo-tree
      :ensure t
      :init
      (global-undo-tree-mode))
  #+END_SRC
* Misc packages
  #+BEGIN_SRC emacs-lisp

  ; Highlights the current cursor line
  (global-hl-line-mode t)
  
  ; flashes the cursor's line when you scroll
  (use-package beacon
  :ensure t
  :config
  (beacon-mode 1)
  ; (setq beacon-color "#666600")
  )
  
  ; deletes all the whitespace when you hit backspace or delete
  (use-package hungry-delete
  :ensure t
  :config
  (global-hungry-delete-mode))
  

  (use-package multiple-cursors
  :ensure t)

  ; expand the marked region in semantic increments (negative prefix to reduce region)
  (use-package expand-region
  :ensure t
  :config 
  (global-set-key (kbd "C-=") 'er/expand-region))

(setq save-interprogram-paste-before-kill t)


(global-auto-revert-mode 1) ;; you might not want this
(setq auto-revert-verbose nil) ;; or this
(global-set-key (kbd "<f5>") 'revert-buffer)
(global-set-key (kbd "<f6>") 'revert-buffer)


  
  #+END_SRC

* iedit and narrow / widen dwim

  #+BEGIN_SRC emacs-lisp
  ; mark and edit all copies of the marked region simultaniously. 
  (use-package iedit
  :ensure t)
  
  ; if you're windened, narrow to the region, if you're narrowed, widen
  ; bound to C-x n
  (defun narrow-or-widen-dwim (p)
  "If the buffer is narrowed, it widens. Otherwise, it narrows intelligently.
  Intelligently means: region, org-src-block, org-subtree, or defun,
  whichever applies first.
  Narrowing to org-src-block actually calls `org-edit-src-code'.
  
  With prefix P, don't widen, just narrow even if buffer is already
  narrowed."
  (interactive "P")
  (declare (interactive-only))
  (cond ((and (buffer-narrowed-p) (not p)) (widen))
  ((region-active-p)
  (narrow-to-region (region-beginning) (region-end)))
  ((derived-mode-p 'org-mode)
  ;; `org-edit-src-code' is not a real narrowing command.
  ;; Remove this first conditional if you don't want it.
  (cond ((ignore-errors (org-edit-src-code))
  (delete-other-windows))
  ((org-at-block-p)
  (org-narrow-to-block))
  (t (org-narrow-to-subtree))))
  (t (narrow-to-defun))))
  
  ;; (define-key endless/toggle-map "n" #'narrow-or-widen-dwim)
  ;; This line actually replaces Emacs' entire narrowing keymap, that's
  ;; how much I like this command. Only copy it if that's what you want.
  (define-key ctl-x-map "n" #'narrow-or-widen-dwim)
  
  #+END_SRC


  #+RESULTS:
  : narrow-or-widen-dwim

* Web Mode
#+BEGIN_SRC emacs-lisp
    (use-package web-mode
      :ensure t
      :config
	   (add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
	   (add-to-list 'auto-mode-alist '("\\.vue?\\'" . web-mode))
	   (setq web-mode-engines-alist
		 '(("django"    . "\\.html\\'")))
	   (setq web-mode-ac-sources-alist
	   '(("css" . (ac-source-css-property))
	   ("vue" . (ac-source-words-in-buffer ac-source-abbrev))
           ("html" . (ac-source-words-in-buffer ac-source-abbrev))))
  (setq web-mode-enable-auto-closing t))
  (setq web-mode-enable-auto-quoting t) ; this fixes the quote problem I mentioned


#+END_SRC

#+RESULTS:
: t
* Emmet mode
#+BEGIN_SRC emacs-lisp
(use-package emmet-mode
:ensure t
:config
(add-hook 'sgml-mode-hook 'emmet-mode) ;; Auto-start on any markup modes
(add-hook 'web-mode-hook 'emmet-mode) ;; Auto-start on any markup modes
(add-hook 'css-mode-hook  'emmet-mode) ;; enable Emmet's css abbreviation.
)
#+END_SRC
* Javascript
#+BEGIN_SRC emacs-lisp
(use-package js2-mode
:ensure t
:ensure ac-js2
:init
(progn
(add-hook 'js-mode-hook 'js2-minor-mode)
(add-hook 'js2-mode-hook 'ac-js2-mode)
))

(use-package js2-refactor
:ensure t
:config 
(progn
(js2r-add-keybindings-with-prefix "C-c C-m")
;; eg. extract function with `C-c C-m ef`.
(add-hook 'js2-mode-hook #'js2-refactor-mode)))
(use-package tern
:ensure tern
:ensure tern-auto-complete
:config
(progn
(add-hook 'js-mode-hook (lambda () (tern-mode t)))
(add-hook 'js2-mode-hook (lambda () (tern-mode t)))
(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
;;(tern-ac-setup)
))

;;(use-package jade
;;:ensure t
;;)

;; use web-mode for .jsx files
(add-to-list 'auto-mode-alist '("\\.jsx$" . web-mode))


;; turn on flychecking globally
(add-hook 'after-init-hook #'global-flycheck-mode)

;; disable jshint since we prefer eslint checking
(setq-default flycheck-disabled-checkers
  (append flycheck-disabled-checkers
    '(javascript-jshint)))

;; use eslint with web-mode for jsx files
(flycheck-add-mode 'javascript-eslint 'web-mode)

;; customize flycheck temp file prefix
(setq-default flycheck-temp-prefix ".flycheck")

;; disable json-jsonlist checking for json files
(setq-default flycheck-disabled-checkers
  (append flycheck-disabled-checkers
    '(json-jsonlist)))

;; adjust indents for web-mode to 2 spaces
(defun my-web-mode-hook ()
  "Hooks for Web mode. Adjust indents"
  ;;; http://web-mode.org/
  (setq web-mode-markup-indent-offset 2)
  (setq web-mode-css-indent-offset 2)
  (setq web-mode-code-indent-offset 2))
(add-hook 'web-mode-hook  'my-web-mode-hook)
#+END_SRC 

* DIRED
#+BEGIN_SRC emacs-lisp
; wiki melpa problem
;(use-package dired+
;  :ensure t
;  :config (require 'dired+)
;  )

(setq dired-dwim-target t)

(use-package dired-narrow
:ensure t
:config
(bind-key "C-c C-n" #'dired-narrow)
(bind-key "C-c C-f" #'dired-narrow-fuzzy)
(bind-key "C-x C-N" #'dired-narrow-regexp)
)

(use-package dired-subtree :ensure t
  :after dired
  :config
  (bind-key "<tab>" #'dired-subtree-toggle dired-mode-map)
  (bind-key "<backtab>" #'dired-subtree-cycle dired-mode-map))


#+END_SRC

#+RESULTS:
: t

* Stuff to refile as I do more Screencasts
#+BEGIN_SRC emacs-lisp

    ;;--------------------------------------------------------------------------
    ;; latex
    (use-package tex
    :ensure auctex)

    (defun tex-view ()
        (interactive)
        (tex-send-command "evince" (tex-append tex-print-file ".pdf")))
  ;; babel stuff

    (org-babel-do-load-languages
     'org-babel-load-languages
     '((python . t)
       (emacs-lisp . t)
(shell . t)
       (C . t)
    (js . t)
       (ditaa . t)
       (dot . t)
       (org . t)
    (latex . t )
       ))
  ;; projectile
    (use-package projectile
      :ensure t
      :bind ("C-c p" . projectile-command-map)
      :config
      (projectile-global-mode)
    (setq projectile-completion-system 'ivy))

    ;; (use-package counsel-projectile
    ;;   :ensure t
    ;;   :config
    ;;   (counsel-projectile-on)q)
  
(use-package smartparens
:ensure t
  :hook (prog-mode . smartparens-mode)
  :custom
  (sp-escape-quotes-after-insert nil)
  :config
  (require 'smartparens-config))

(show-paren-mode t)
    ;;--------------------------------------------



  
    ;; font scaling
    (use-package default-text-scale
      :ensure t
     :config
      (global-set-key (kbd "C-M-=") 'default-text-scale-increase)
      (global-set-key (kbd "C-M--") 'default-text-scale-decrease))


    ;; (use-package frame-cmds :ensure t)
    ;; (load-file "/home/zamansky/Dropbox/shared/zoom-frm.el")
    ;; (define-key ctl-x-map [(control ?+)] 'zoom-in/out)
    ;; (define-key ctl-x-map [(control ?-)] 'zoom-in/out)
    ;; (define-key ctl-x-map [(control ?=)] 'zoom-in/out)
    (define-key ctl-x-map [(control ?0)] 'zoom-in/out)


#+END_SRC
* Hydra
#+BEGIN_SRC emacs-lisp
  (use-package hydra 
    :ensure hydra
    :init 
    (global-set-key
    (kbd "C-x t")
	    (defhydra toggle (:color blue)
	      "toggle"
	      ("a" abbrev-mode "abbrev")
	      ("s" flyspell-mode "flyspell")
	      ("d" toggle-debug-on-error "debug")
	      ("c" fci-mode "fCi")
	      ("f" auto-fill-mode "fill")
	      ("t" toggle-truncate-lines "truncate")
	      ("w" whitespace-mode "whitespace")
	      ("q" nil "cancel")))
    (global-set-key
     (kbd "C-x j")
     (defhydra gotoline 
       ( :pre (linum-mode 1)
	      :post (linum-mode -1))
       "goto"
       ("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")
       ("e" (lambda () (interactive)(end-of-buffer)) "end")
       ("c" recenter-top-bottom "recenter")
       ("n" next-line "down")
       ("p" (lambda () (interactive) (forward-line -1))  "up")
       ("g" goto-line "goto-line")
       ))
    (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" (or )rg-capture-goto-last-stored "Last Capture"))

     ))

(defhydra hydra-multiple-cursors (:hint nil)
  "
 Up^^             Down^^           Miscellaneous           % 2(mc/num-cursors) cursor%s(if (> (mc/num-cursors) 1) \"s\" \"\")
------------------------------------------------------------------
 [_p_]   Next     [_n_]   Next     [_l_] Edit lines  [_0_] Insert numbers
 [_P_]   Skip     [_N_]   Skip     [_a_] Mark all    [_A_] Insert letters
 [_M-p_] Unmark   [_M-n_] Unmark   [_s_] Search
 [Click] Cursor at point       [_q_] Quit"
  ("l" mc/edit-lines :exit t)
  ("a" mc/mark-all-like-this :exit t)
  ("n" mc/mark-next-like-this)
  ("N" mc/skip-to-next-like-this)
  ("M-n" mc/unmark-next-like-this)
  ("p" mc/mark-previous-like-this)
  ("P" mc/skip-to-previous-like-this)
  ("M-p" mc/unmark-previous-like-this)
  ("s" mc/mark-all-in-region-regexp :exit t)
  ("0" mc/insert-numbers :exit t)
  ("A" mc/insert-letters :exit t)
  ("<mouse-1>" mc/add-cursor-on-click)
  ;; Help with click recognition in this hydra
  ("<down-mouse-1>" ignore)
  ("<drag-mouse-1>" ignore)
  ("q" nil)


  ("<mouse-1>" mc/add-cursor-on-click)
  ("<down-mouse-1>" ignore)
  ("<drag-mouse-1>" ignore))

#+END_SRC

#+RESULTS:

* git
#+BEGIN_SRC emacs-lisp
  (use-package magit
    :ensure t
    :init
    (progn
    (bind-key "C-x g" 'magit-status)
    ))

(setq magit-status-margin
  '(t "%Y-%m-%d %H:%M " magit-log-margin-width t 18))
    (use-package git-gutter
    :ensure t
    :init
    (global-git-gutter-mode +1))

    (global-set-key (kbd "M-g M-g") 'hydra-git-gutter/body)


    (use-package git-timemachine
    :ensure t
    )
  (defhydra hydra-git-gutter (:body-pre (git-gutter-mode 1)
                              :hint nil)
    "
  Git gutter:
    _j_: next hunk        _s_tage hunk     _q_uit
    _k_: previous hunk    _r_evert hunk    _Q_uit and deactivate git-gutter
    ^ ^                   _p_opup hunk
    _h_: first hunk
    _l_: last hunk        set start _R_evision
  "
    ("j" git-gutter:next-hunk)
    ("k" git-gutter:previous-hunk)
    ("h" (progn (goto-char (point-min))
                (git-gutter:next-hunk 1)))
    ("l" (progn (goto-char (point-min))
                (git-gutter:previous-hunk 1)))
    ("s" git-gutter:stage-hunk)
    ("r" git-gutter:revert-hunk)
    ("p" git-gutter:popup-hunk)
    ("R" git-gutter:set-start-revision)
    ("q" nil :color blue)
    ("Q" (progn (git-gutter-mode -1)
                ;; git-gutter-fringe doesn't seem to
                ;; clear the markup right away
                (sit-for 0.1)
                (git-gutter:clear))
         :color blue))



#+END_SRC
* Load other files
   #+BEGIN_SRC emacs-lisp
     (defun load-if-exists (f)
       "load the elisp file only if it exists and is readable"
       (if (file-readable-p f)
           (load-file f)))

     (load-if-exists "~/Sync/shared/mu4econfig.el")
     (load-if-exists "~/Sync/shared/not-for-github.el")

   #+END_SRC

   #+RESULTS:
   : t
* Testing Stuff
#+BEGIN_SRC emacs-lisp
(add-hook 'org-mode-hook 'turn-on-flyspell)
(add-hook 'org-mode-hook 'turn-on-auto-fill)
(add-hook 'mu4e-compose-mode-hook 'turn-on-flyspell)
(add-hook 'mu4e-compose-mode-hook 'turn-on-auto-fill)

#+END_SRC
* Better Shell
#+BEGIN_SRC emacs-lisp :tangle no
  (use-package better-shell
      :ensure t
      :bind (("C-\"" . better-shell-shell)
             ("C-:" . better-shell-remote-open)))
#+END_SRC

#+RESULTS:
: better-shell-remote-open

* Elfeed
#+BEGIN_SRC emacs-lisp :tangle no

    (setq elfeed-db-directory "~/Sync/shared/elfeeddb")


    (defun elfeed-mark-all-as-read ()
	  (interactive)
	  (mark-whole-buffer)
	  (elfeed-search-untag-all-unread))


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

    ;;write to disk when quiting
    (defun bjm/elfeed-save-db-and-bury ()
      "Wrapper to save the elfeed db to disk before burying buffer"
      (interactive)
      (elfeed-db-save)
      (quit-window))




    (use-package elfeed
      :ensure t
      :bind (:map elfeed-search-mode-map
		  ("q" . bjm/elfeed-save-db-and-bury)
		  ("Q" . bjm/elfeed-save-db-and-bury)
		  ("m" . elfeed-toggle-star)
		  ("M" . elfeed-toggle-star)
		  ("j" . mz/make-and-run-elfeed-hydra)
		  ("J" . mz/make-and-run-elfeed-hydra)
		  )
:config
    (defalias 'elfeed-toggle-star
      (elfeed-expose #'elfeed-search-toggle-all 'star))

      )

    (use-package elfeed-goodies
      :ensure t
      :config
      (elfeed-goodies/setup))


    (use-package elfeed-org
      :ensure t
      :config
      (elfeed-org)
      (setq rmh-elfeed-org-files (list "~/Sync/shared/elfeed.org")))





  (defun z/hasCap (s) ""
	 (let ((case-fold-search nil))
	 (string-match-p "[[:upper:]]" s)
	 ))


  (defun z/get-hydra-option-key (s)
    "returns single upper case letter (converted to lower) or first"
    (interactive)
    (let ( (loc (z/hasCap s)))
      (if loc
	  (downcase (substring s loc (+ loc 1)))
	(substring s 0 1)
      )))

  ;;  (active blogs cs eDucation emacs local misc sports star tech unread webcomics)
  (defun mz/make-elfeed-cats (tags)
    "Returns a list of lists. Each one is line for the hydra configuratio in the form
       (c function hint)"
    (interactive)
    (mapcar (lambda (tag)
	      (let* (
		     (tagstring (symbol-name tag))
		     (c (z/get-hydra-option-key tagstring))
		     )
		(list c (append '(elfeed-search-set-filter) (list (format "@6-months-ago +%s" tagstring) ))tagstring  )))
	    tags))




  
  (defmacro mz/make-elfeed-hydra ()
    `(defhydra mz/hydra-elfeed ()
       "filter"
       ,@(mz/make-elfeed-cats (elfeed-db-get-all-tags))
       ("*" (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)
       ))




    (defun mz/make-and-run-elfeed-hydra ()
      ""
      (interactive)
      (mz/make-elfeed-hydra)
      (mz/hydra-elfeed/body))


#+END_SRC

#+RESULTS:
: mz/make-and-run-elfeed-hydra

* c++
#+BEGIN_SRC emacs-lisp
(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))))
)

#+END_SRC

#+RESULTS:

* Clojure
#+BEGIN_SRC emacs-lisp
 (use-package cider
    :ensure t
    :config
    (add-hook 'cider-repl-mode-hook #'company-mode)
    (add-hook 'cider-mode-hook #'company-mode)
    (add-hook 'cider-mode-hook #'eldoc-mode)
;;    (add-hook 'cider-mode-hook #'cider-hydra-mode)
    (setq cider-repl-use-pretty-printing t)
    (setq cider-repl-display-help-banner nil)
    ;;    (setq cider-cljs-lein-repl "(do (use 'figwheel-sidecar.repl-api) (start-figwheel!) (cljs-repl))")

    :bind (("M-r" . cider-namespace-refresh)
           ("C-c r" . cider-repl-reset)
           ("C-c ." . cider-reset-test-run-tests))
    )

  (use-package clj-refactor
    :ensure t
    :config
    (add-hook 'clojure-mode-hook (lambda ()
                                   (clj-refactor-mode 1)
                                   ;; insert keybinding setup here
                                   ))
    (cljr-add-keybindings-with-prefix "C-c C-m")
    (setq cljr-warn-on-eval nil)
    :bind ("C-c '" . hydra-cljr-help-menu/body)
    )
#+END_SRC


* Dumb jump
#+BEGIN_SRC emacs-lisp

(use-package dumb-jump
  :bind (("M-g o" . dumb-jump-go-other-window)
         ("M-g j" . dumb-jump-go)
         ("M-g x" . dumb-jump-go-prefer-external)
         ("M-g z" . dumb-jump-go-prefer-external-other-window))
  :config 
  ;; (setq dumb-jump-selector 'ivy) ;; (setq dumb-jump-selector 'helm)
:init
(dumb-jump-mode)
  :ensure
)



#+END_SRC
* Origami folding
#+BEGIN_SRC emacs-lisp
(use-package origami
:ensure t)
#+END_SRC

#+RESULTS:

* IBUFFER
#+BEGIN_SRC emacs-lisp
  (global-set-key (kbd "C-x C-b") 'ibuffer)
  (setq ibuffer-saved-filter-groups
        (quote (("default"
                 ("dired" (mode . dired-mode))
                 ("org" (name . "^.*org$"))
                 ("magit" (mode . magit-mode))
                 ("IRC" (or (mode . circe-channel-mode) (mode . circe-server-mode)))
                 ("web" (or (mode . web-mode) (mode . js2-mode)))
                 ("shell" (or (mode . eshell-mode) (mode . shell-mode)))
                 ("mu4e" (or

                          (mode . mu4e-compose-mode)
                          (name . "\*mu4e\*")
                          ))
                 ("programming" (or
                                 (mode . clojure-mode)
                                 (mode . clojurescript-mode)
                                 (mode . python-mode)
                                 (mode . c++-mode)))
                 ("emacs" (or
                           (name . "^\\*scratch\\*$")
                           (name . "^\\*Messages\\*$")))
                 ))))
  (add-hook 'ibuffer-mode-hook
            (lambda ()
              (ibuffer-auto-mode 1)
              (ibuffer-switch-to-saved-filter-groups "default")))

  ;; don't show these
                                          ;(add-to-list 'ibuffer-never-show-predicates "zowie")
  ;; Don't show filter groups if there are no buffers in that group
  (setq ibuffer-show-empty-filter-groups nil)

  ;; Don't ask for confirmation to delete marked buffers
  (setq ibuffer-expert t)

#+END_SRC
* Treemacs
#+BEGIN_SRC emacs-lisp
  (use-package treemacs
    :ensure t
    :defer t
    :config
    (progn

      (setq treemacs-follow-after-init          t
            treemacs-width                      35
            treemacs-indentation                2
            treemacs-git-integration            t
            treemacs-collapse-dirs              3
            treemacs-silent-refresh             nil
            treemacs-change-root-without-asking nil
            treemacs-sorting                    'alphabetic-desc
            treemacs-show-hidden-files          t
            treemacs-never-persist              nil
            treemacs-is-never-other-window      nil
            treemacs-goto-tag-strategy          'refetch-index)

      (treemacs-follow-mode t)
      (treemacs-filewatch-mode t))
    :bind
    (:map global-map
          ([f8]        . treemacs-toggle)
          ([f9]        . treemacs-projectile-toggle)
          ("<C-M-tab>" . treemacs-toggle)
          ("M-0"       . treemacs-select-window)
          ("C-c 1"     . treemacs-delete-other-windows)
        ))
  (use-package treemacs-projectile
    :defer t
    :ensure t
    :config
    (setq treemacs-header-function #'treemacs-projectile-create-header)
)

#+END_SRC

#+RESULTS:

* misc
#+BEGIN_SRC emacs-lisp

(use-package aggressive-indent
:ensure t
:config
(global-aggressive-indent-mode 1)
;;(add-to-list 'aggressive-indent-excluded-modes 'html-mode)
)


(defun z/swap-windows ()
""
(interactive)
(ace-swap-window)
(aw-flip-window)
)

#+END_SRC

#+RESULTS:
: z/nikola-deploy
* Haskell 
#+BEGIN_SRC emacs-lisp
(use-package haskell-mode
:ensure t
:config
(require 'haskell-interactive-mode)
(require 'haskell-process)
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)

)

#+END_SRC
* personal keymap
#+BEGIN_SRC emacs-lisp
;; unset C- and M- digit keys
;(dotimes (n 10)
;  (global-unset-key (kbd (format "C-%d" n)))
;  (global-unset-key (kbd (format "M-%d" n)))
;  )


(defun org-agenda-show-agenda-and-todo (&optional arg)
  (interactive "P")
  (org-agenda arg "c")
  (org-agenda-fortnight-view))

(defun z/load-iorg ()
(interactive )
(find-file "~/Sync/orgfiles/i.org"))

;; set up my own map
(define-prefix-command 'z-map)
(global-set-key (kbd "C-z") 'z-map) ;; was C-1
(define-key z-map (kbd "k") 'compile)
(define-key z-map (kbd "c") 'hydra-multiple-cursors/body)
(define-key z-map (kbd "m") 'mu4e)
(define-key z-map (kbd "1") 'org-global-cycle)
(define-key z-map (kbd "a") 'org-agenda-show-agenda-and-todo)
(define-key z-map (kbd "g") 'counsel-ag)
(define-key z-map (kbd "2") 'make-frame-command)
(define-key z-map (kbd "0") 'delete-frame)
(define-key z-map (kbd "o") 'ace-window)

(define-key z-map (kbd "s") 'flyspell-correct-word-before-point)
(define-key z-map (kbd "i") 'z/load-iorg)
(define-key z-map (kbd "f") 'origami-toggle-node)
(define-key z-map (kbd "w") 'z/swap-windows)
(define-key z-map (kbd "*") 'calc)


  (setq user-full-name "Mike Zamansky"
                          user-mail-address "mz631@hunter.cuny.edu")
  ;;--------------------------------------------------------------------------


  (global-set-key (kbd "\e\ei")
                  (lambda () (interactive) (find-file "~/Sync/orgfiles/i.org")))

  (global-set-key (kbd "\e\el")
                  (lambda () (interactive) (find-file "~/Sync/orgfiles/links.org")))

  (global-set-key (kbd "\e\ec")
                  (lambda () (interactive) (find-file "~/.emacs.d/myinit.org")))

(global-set-key (kbd "<end>") 'move-end-of-line)

(global-set-key [mouse-3] 'flyspell-correct-word-before-point)

#+END_SRC

#+RESULTS:
: origami-toggle-node

#  LocalWords:  DIRED Javascript Screencasts Autocomplete
* Wgrep
#+BEGIN_SRC emacs-lisp
(use-package wgrep
:ensure t
)
(use-package wgrep-ag
:ensure t
)
(require 'wgrep-ag)
#+END_SRC

#+RESULTS:
* Silversearcher
#+BEGIN_SRC emacs-lisp
(use-package ag
:ensure t)

#+END_SRC
* Regex
#+BEGIN_SRC emacs-lisp
(use-package pcre2el
:ensure t
:config 
(pcre-mode)
)
#+END_SRC
* Eyebrowse
#+BEGIN_SRC emacs-lisp :tangle no
(use-package eyebrowse
:ensure t
:config 
(eyebrowse-mode)
)

#+END_SRC

#+RESULTS:

* Music
#+BEGIN_SRC emacs-lisp
(use-package simple-mpc
:ensure t)
(use-package mingus
:ensure t)

#+END_SRC
* Atomic Chrome (edit in emacs)
#+BEGIN_SRC emacs-lisp
(use-package atomic-chrome
:ensure t
:config (atomic-chrome-start-server))
(setq atomic-chrome-buffer-open-style 'frame)
#+END_SRC
* PDF tools
#+BEGIN_SRC emacs-lisp
(use-package pdf-tools
:ensure t)
(use-package org-pdfview
:ensure t)

(require 'pdf-tools)
(require 'org-pdfview)

#+END_SRC
* auto-yasnippet
#+BEGIN_SRC emacs-lisp
(use-package auto-yasnippet
:ensure t)
#+END_SRC
* mu4e-conversation
#+BEGIN_SRC emacs-lisp :tangle no
(use-package mu4e-conversation
:ensure t
)

#+END_SRC
* Unfill region and paragraph
#+BEGIN_SRC emacs-lisp
  ;;; Stefan Monnier <foo at acm.org>. It is the opposite of fill-paragraph    
    (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)))

(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)))


#+END_SRC
* Easy kill
#+BEGIN_SRC emacs-lisp
  ;; (use-package easy-kill
  ;;   :ensure t
  ;;   :config
  ;;   (global-set-key [remap kill-ring-save] #'easy-kill)
  ;;   (global-set-key [remap mark-sexp] #'easy-mark))

#+END_SRC

* PATH 
#+BEGIN_SRC emacs-lisp
(use-package exec-path-from-shell
:ensure t
:config
(exec-path-from-shell-initialize)
)
#+END_SRC
* Counsel-spotify
#+begin_src emacs-lisp

(setq counsel-spotify-client-id "ce31becb1af94921907671e4bfa7f558")
(setq counsel-spotify-client-secret "9433b011b7094b2b8c4eb0255b8249e3")
(use-package counsel-spotify
:ensure t
:config
(require 'counsel-spotify)
)
#+end_src
* Misc


#+BEGIN_SRC emacs-lisp
(setq browse-url-browser-function 'browse-url-generic
      browse-url-generic-program "firefox")

(setq auto-window-vscroll nil)

#+END_SRC

* Keyfreq
#+BEGIN_SRC emacs-lisp
  (use-package keyfreq
    :ensure t
    :config
    (require 'keyfreq)
    (keyfreq-mode 1)
    (keyfreq-autosave-mode 1)
    )
#+END_SRC
* Word stuff
#+BEGIN_SRC emacs-lisp
  (use-package dictionary
    :ensure t)

  (use-package synosaurus
    :ensure t)

#+END_SRC
* Rust
#+BEGIN_SRC emacs-lisp
;; don't forget to install racer:
;; rustup toolchain add nightly
;; cargo +nightly install racer
;; rustup component add rust-src
;; rustup component add rustfmt
(use-package racer
  :ensure t
  :config
  (add-hook 'racer-mode-hook #'company-mode)
  (setq company-tooltip-align-annotations t)
  (setq racer-rust-src-path "~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src"))

(use-package rust-mode
  :ensure t
  :config
  (add-hook 'rust-mode-hook #'racer-mode)
  (add-hook 'racer-mode-hook #'eldoc-mode)
  (setq rust-format-on-save t))

(use-package cargo
  :ensure t
  :config
  (setq compilation-scroll-output t)
  (add-hook 'rust-mode-hook 'cargo-minor-mode))

(use-package flycheck-rust
  :ensure t
  :config
  (add-hook 'flycheck-mode-hook #'flycheck-rust-setup)
  (add-hook 'rust-mode-hook 'flycheck-mode))

#+END_SRC
* Ripgrep
#+BEGIN_SRC emacs-lisp
(use-package deadgrep 
:ensure t)

(use-package rg
:ensure t
:commands rg)

#+END_SRC
* Fzf
#+BEGIN_SRC emacs-lisp
(use-package fzf :ensure t)
#+END_SRC
* All the icons

#+BEGIN_SRC emacs-lisp
(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)

#+END_SRC