config.org

#+TITLE: doom
* Personal Information
** Set full name
#+begin_src elisp
(setq user-full-name "Nils Froleyks")
#+end_src
** Set email address
#+begin_src elisp
(setq user-mail-address "nfroleyks@gmail.com")
#+end_src
* Visual
** Font
#+begin_src elisp
(setq doom-font (font-spec :family "Source Code Pro" :size 18 :weight 'semi-light)
    ;; doom-variable-pitch-font (font-spec :family "sans" :size 20)
    )
#+end_src
** line numbers
#+begin_src elisp
(setq display-line-numbers-type 'visual)
(global-display-line-numbers-mode)
#+end_src
* Keybindings
** Delete last word
#+begin_src elisp
(map! :nivr "M-v" 'backward-kill-word)
(map! :after ivy       :map ivy-minibuffer-map "M-v" 'backward-kill-word)
(map! :after evil-vars :map evil-ex-search-keymap "M-v" 'backward-kill-word)
#+end_src
** global help
#+begin_src elisp
(map! [C-f1] 'helpful-key)
#+end_src
** goto mark
#+begin_src elisp
(map! :n "j" 'evil-goto-mark)
#+end_src
** window
#+begin_src elisp
(map! :after evil-commands :leader
    "wl" 'evil-window-up
    "wa" 'evil-window-down
    "wi" 'evil-window-left
    "we" 'evil-window-right
    )
#+end_src
** gedankenstrich move up
#+begin_src elisp
(map! :after evil-commands :n "−" 'evil-previous-line-first-non-blank)
#+end_src
** last macro
#+begin_src elisp
(map! :n "Q" (kbd"@@"))
#+end_src
** undo
#+begin_src elisp
(map! :after evil-commands
 :n "U" 'evil-redo
 :nivr "C-n" 'undo-fu-only-undo
 )
#+end_src
** open frame other buffer
#+begin_src elisp
(map! :leader "bo" 'display-buffer-other-frame)
#+end_src
** line numbers visual
#+begin_src elisp
(map! :leader "tv" 'menu-bar--display-line-numbers-mode-visual)
#+end_src
** surround
#+begin_src elisp
(map! :after evil-surround :mode evil-surround-mode
      :n "S" 'evil-surround-region
      :v "s" 'evil-surround-region
      :v "S" 'evil-Surround-region
      )
#+end_src
** multiple cursor
#+begin_src elisp
(map! :nv "H" 'evil-mc-make-all-cursors)
#+end_src
* General
** Narrow to an indirect buffer
#+begin_src elisp
(after! evil-commands
  (map! :nv "h" 'evil-narrow-op)
  (evil-define-operator evil-narrow-op (beg end type)
    "Evil indirect *narrow* operator."
    (interactive "<R>")
    (deactivate-mark)
    (let ((buf (clone-indirect-buffer nil nil)))
      (with-current-buffer buf
        (narrow-to-region beg end))
      (switch-to-buffer buf))))
#+end_src
** ivy
#+begin_src elisp
(use-package! ivy
    :bind (:map ivy-minibuffer-map
        ("C-e" . ivy-unmark)
        ("M-e" . ivy-mark)
        ("M-n" . ivy-absolute-path)
        ("M-r" . ivy-relative-path)
        ("(" . ivy-dispatching-call)
    )
    :custom
    (counsel-find-file-ignore-regexp nil) ;show all files
    :config
    (defun ivy-relative-path ()
        (interactive)
        (ivy-exit-with-action
            (lambda (path) (with-ivy-window (insert (file-relative-name path default-directory))))
            ))
    (defun ivy-absolute-path ()
        (interactive)
        (ivy-exit-with-action
            (lambda (path) (with-ivy-window (insert path)))
            ))
)
#+end_src
** backup
#+begin_src elisp
(map! :leader "gv" 'visit-backup)
(add-hook 'after-save-hook 'backup-each-save)
(use-package! backup-each-save
  :commands backup-each-save visit-backup
  :custom
  (backup-each-save-mirror-location "~/emacs/save")
  :config
  (defun visit-backup ()
    (interactive)
    (counsel-find-file (concat "~/emacs/save" default-directory))
    )
  )
#+end_src
** jump history
#+begin_src elisp
(use-package! better-jumper
  :defer t
  :config
    (defun my-jump-advice (oldfun &rest args)
        (let ((old-pos (point)))
        (apply oldfun args)
        (when (> (abs (- (line-number-at-pos old-pos)
                        (line-number-at-pos (point)))) 5)
            (save-excursion
            (goto-char old-pos)
            (evil-set-jump)))))

    (advice-add 'evil-next-line :around #'my-jump-advice)
    (advice-add 'evil-previous-line :around #'my-jump-advice)
    )
#+end_src
** evil mark
*** default markers
#+begin_src elisp
(after! evil-commands
    (setq alist (default-value 'evil-markers-alist))

    (evil-add-to-alist 'alist ?C '("/home/froleyks/.config/doom/config.org" . 116))

    (setq-default evil-markers-alist alist)
)
#+end_src
*** disable visit again question and bugfix
#+begin_src elisp
(evil-define-command evil-goto-mark (char &optional noerror)
  "Go to the marker specified by CHAR."
  :keep-visual t
  :repeat nil
  :type exclusive
  (interactive (list (read-char)))
  (let ((marker (evil-get-marker char)))
    (cond
     ((markerp marker)
      (switch-to-buffer (marker-buffer marker))
      (goto-char (marker-position marker)))
     ((numberp marker)
      (goto-char marker))
     ((consp marker)
      (when (or (and (find-buffer-visiting (car marker))
                     (switch-to-buffer (find-buffer-visiting (car marker)) )
                     )
                (and ;; (y-or-n-p (format "Visit file %s again? "
                     ;;                   (car marker)))
                     (find-file (car marker))))
        (goto-char (cdr marker))))
     ((not noerror)
      (user-error "Marker `%c' is not set%s" char
                  (if (evil-global-marker-p char) ""
                    " in this buffer"))))))
#+end_src
** avy keys
#+begin_src elisp
(after! avy
  (setq avy-keys '(?n ?e ?r ?a ?t ?i ?d ?u ?s ?o))
  (setq avy-dispatch-alist '(
    (?x . avy-action-kill-move)
    (?X . avy-action-kill-stay)
    (?p . avy-action-teleport)
    (?m . avy-action-mark)
    (?c . avy-action-copy)
    (?y . avy-action-yank)
    (?Y . avy-action-yank-line)
    (?w . avy-action-ispell)
    (?z . avy-action-zap-to-char)
    ))
  )
#+end_src
** linenumbers everywhere
#+begin_src elisp
;; (add-hook 'dired-mode-hook
;;        'doom/toggle-line-numbers)
#+end_src
* Utility
** hippie expand
#+begin_src elisp
(map! :nivr "C-e" 'hippie-expand)
#+end_src
** rotate text
#+begin_src elisp
(map! :n
"ö" 'froleyks-search-rotate-backward
"ä" 'froleyks-search-rotate
)
(use-package! rotate-text
:defer t
:commands (froleyks-search-rotate froleyks-search-rotate-backward)
:init
:config
(defun froleyks-search-rotate()
(interactive)
(search-forward-regexp  "\\(\\+\\|-\\)?[0-9]+\\(\\.[0-9]+\\)?\\|true\\|false\\|first\\|second\\|yes\\|no\\|nil\\|t" nil t)
(call-interactively 'rotate-text)
(evil-backward-WORD-begin)
)

(defun froleyks-search-rotate-backward()
(interactive)
(search-forward-regexp  "\\(\\+\\|-\\)?[0-9]+\\(\\.[0-9]+\\)?\\|true\\|false\\|first\\|second\\|yes\\|no\\|nil\\|t" nil t)
(call-interactively 'rotate-text-backward)
(evil-backward-WORD-begin)
)

;; override function to keep width
(defun rotate-text-increment-number (original arg &optional minimum)
(let ((l (length original)))
(format (concat "%0" (number-to-string l) "d" )(max (+ (string-to-number original) arg)
                        (or minimum most-negative-fixnum)))))

(setq rotate-text-words (append rotate-text-words '(
("True" "False")
("nil" "t")
("true" "false")
("first" "second")
("yes" "no")
))))
#+end_src
** temp files
#+begin_src elisp
(after! counsel
(map! :leader "d" 'open-temp-file)
(defun open-temp-file()
(interactive)
(counsel-find-file "~/temp/temp.")
))
#+end_src
** escape saves and exits
#+begin_src elisp
(defadvice! save-on-escape (&rest _)
:before #'evil-force-normal-state
(when (or
    (buffer-narrowed-p)
    (buffer-file-name)
    (string-match-p (regexp-quote "Org Src") (buffer-name))
    )
(save-buffer))
(when (buffer-narrowed-p)
(kill-current-buffer))
)
#+end_src
** evil snipe
#+begin_src elisp
(use-package! evil-snipe
:defer t
:init
(setq evil-snipe-override-evil-repeat-keys nil)
:custom
(evil-snipe-scope 'buffer)
:config
(evil-snipe-mode -1)
(map!
    :nv "," 'evil-snipe-repeat
    :nv "–" 'evil-snipe-repeat-reverse
    :nv "l" 'evil-snipe-s
    :nv "L" 'evil-snipe-S
    (:map evil-snipe-parent-transient-map
        "," 'evil-snipe-repeat
        "–" 'evil-snipe-repeat-reverse
    )))
#+end_src
** create body
#+begin_src elisp
(map! "M-o" 'create-body)
(defun create-body()
(interactive)
(end-of-line)
(backward-char)
(newline-and-indent)
(evil-open-above 1)
)
#+end_src
** Line manipulation
#+begin_src elisp
(map! :leader
    "L" '(:ignore t :which-key "Line manipulation")
    (:prefix "L"
    "e" 'flush-empty-lines
    "f" 'flush-lines
    "k" 'keep-lines
    "d" 'remove-dubplicate-lines
    "u" 'unique-lines
    ))
(use-package! replace
:commands (flush-empty-lines remove-dubplicate-lines unique-lines)
:config
(defun unique-lines ()
    (interactive)
    (evil-ex "%sort u")
    )
(defun flush-empty-lines ()
    "removes empty lines from files"
    (interactive)
    (flush-lines "^$")
    )
(defun remove-dubplicate-lines ()
    "removes duplicate lines form file"
    (interactive)
    (replace-regexp "\\([^\n]+\n\\)\\1+" "\\1")
    ))
#+end_src
** pastebin
#+begin_src elisp
(map! :leader
"BB" 'pastebin-new
"BR" 'pastebin-raw
"BL" 'pastebin-list-buffer-refresh
)

(use-package! neopastebin
:defer t
:commands
pastebin-new
pastebin-raw
pastebin-list-buffer-refresh
:config
(pastebin-create-login :dev-key "b05fe24db6a4bca168b463b3fa777bfa"
                        :username "froleyks"
                        :password "shinigami"
                        )
(defun pastebin-raw ()
  (interactive)
  (call-interactively 'pastebin-new)
  )
)
#+END_SRC
#+end_src
** open nautilus
#+begin_src elisp
(map! :leader "fd" 'open-explorer)
(defun open-explorer ()
(interactive)
(call "nautilus .&"))
#+end_src
** Search Engine
#+begin_src elisp
(map! :leader
"sg" 'engine/search-google
"sG" 'engine/search-scholar
"sc" 'engine/search-cpp
"se" 'engine/search-linguee
"sh" 'engine/search-github
"sE" 'engine/search-deepl
)

(use-package! engine-mode
:defer t
:commands (engine/search-google
            engine/search-scholar
            engine/search-cpp
            engine/search-linguee
            engine/search-deepl
            engine/search-github
            )
:config
(defengine google
    "https://www.google.com/search?q=%s")
(defengine scholar
    "https://scholar.google.de/scholar?hl=de&q=%s&btnG=&lr=")
(defengine cpp
    "https://en.cppreference.com/mwiki/index.php?title=Special%%3ASearch&search=%s")
(defengine linguee
    "http://www.linguee.de/deutsch-englisch/search?source=auto&query=%s")
(defengine deepl
    "https://www.deepl.com/en/translator#de/en/%s")
(defengine github
    "https://github.com/search?q=%s&type=code")
)
#+end_src
** spelling
#+begin_src elisp
(map! :map flyspell-mode-map
    :nvir "M-n" 'flyspell-auto-correct-previous-word
    :nvir "M-C-n" 'flyspell-correct-previous
    :leader "tS" 'vale-now
    :leader "tc" 'langtool-check
    :leader "tC" 'langtool-correct-buffer
    :leader "oP" 'academic-phrases
    )

(use-package! ispell :defer t :config
    (setenv "LANG" "en_US")
    (setq ispell-program-name "hunspell")
    (setq ispell-dictionary "de_DE,en_US")
    (add-to-list 'ispell-dictionary-alist '("de_DE,en_US"))
    (ispell-set-spellchecker-params)
    (ispell-hunspell-add-multi-dic "de_DE,en_US")
    (setq ispell-personal-dictionary "~/emacs/dictionary")
    (unless (file-exists-p ispell-personal-dictionary)
    (write-region "" nil ispell-personal-dictionary nil 0))
)

(use-package! langtool
  :defer t
  :commands (langtool-check
             langtool-check-done
             langtool-show-message-at-point
             langtool-correct-buffer)
  :delight
  :custom
  (langtool-default-language "en")
  )

(use-package! academic-phrases
  :commands academic-phrases academic-phrases-by-section)

(use-package! flycheck-vale
  :commands vale-now
  :after flycheck
  :hook (flycheck-mode . flycheck-vale-setup)
  :config
  (flycheck-add-next-checker 'proselint 'vale t)
  (flycheck-add-mode 'vale 'latex-mode)
  (flycheck-add-mode 'vale 'org-mode)
  (defun vale-now()
    (interactive)
    (flycheck-vale-toggle-enabled)
    (flycheck-buffer)
    )
  )
#+end_src
* Mode
** Org
*** keybindgs
#+begin_src elisp
(map! :leader
      "oo" 'org-agenda-list
      "on" 'org-brain-capture
      "ot" 'org-todo-list)
(map! :after org-agenda
      :map org-agenda-keymap
      "ö" 'org-agenda-earlier
      "ä" 'org-agenda-later
      )
(use-package! org
    :commands org-brain-capture
    :config
    (add-to-list 'org-capture-templates
               '("b" "brain" entry (file "~/org/brain.org")
            "* %?%i\n %U %a"))
    (defun org-brain-capture ()
      (interactive)
      (org-capture nil "b")
      (evil-insert 1)
      ))
#+end_src
*** Visual
#+begin_src elisp
(use-package! org
    :defer t
    :custom
    (org-startup-folded t)
    (org-ellipsis " ▾")
    ;; (org-superstar-headline-bullets-list '("◉" "○" "●" "○" "●" "○" "●"))
    ;; (org-superstar-item-bullet-alist
    ;;       '((?+ . ?+)
    ;;         (?* . ?⏭)
    ;;         (?- . ?•)))
    )
#+end_src
*** Export
**** keybindings
#+begin_src elisp
(map! :map org-mode-map
      :leader "e" 'org-ctrl-c-ctrl-c
      :leader "E" 'org-latex-export-to-pdf
      )
#+end_src
**** settings
#+begin_src elisp
(use-package! ox
    :defer t
    :custom
    (org-export-in-background t)
    (org-export-time-stamp-file t)
    (org-export-show-temporary-export-buffer t)
    (org-export-with-priority nil)
    (org-export-headline-levels 3)
    (org-export-with-author nil)
    (org-export-with-title nil)
    (org-export-with-todo-keywords nil)
    (org-export-with-creator nil)
    (org-export-creator-string "Formal Models and Verification - JKU")
    (org-export-with-date t)
    (org-export-dispatch-use-expert-ui nil)
    (org-export-with-timestamps t)
    (org-export-preserve-breaks nil)
    (org-export-with-broken-links 'mark)
    (org-export-with-tasks nil)
    (org-export-with-section-numbers t)
    (org-export-with-email t)
    ;; (org-export-with-archived-trees )
    (org-export-with-smart-quotes t)
    (org-export-with-special-strings t)
    (org-export-with-properties t)
    (org-export-with-toc nil)
    ;; (org-export-before-parsing-hook )
    (org-export-with-tags t)
    (org-export-with-latex t)
    (org-export-use-babel t)
    (org-export-with-tables t)
    (org-export-with-clocks t)
    (org-export-date-timestamp-format  "%Y-%m-%d %A %H:%M")
    (org-export-with-planning nil)
    (org-export-async-debug t)
    (org-export-with-fixed-width t)
    (org-export-with-entities t)
    (org-export-with-emphasize t)
    (org-export-with-sub-superscripts t)
    (org-export-with-statistics-cookies nil)
    (org-export-allow-bind-keywords t)
    :config
    (setq org-tag-alist '(
                          ("noexport" . ?n)
                          ("ignore" . ?i)
                          ))

    (setq org-export-snippet-translation-alist '(
                          ("l" . "latex")
                          ))
    )
(use-package! ox-extra
    :after ox
    :config
    (ox-extras-activate '(latex-header-blocks ignore-headlines))
    )
#+end_src
**** functions
#+begin_src elisp
(use-package! ox
    :defer t
    :commands
    key
    link
    head
    from
    :config

    (defun key (keyword &optional delimiter)
      (unless delimiter (setq delimiter " "))
        (mapconcat 'car (org-element-map
       (org-element-parse-buffer)
       '(keyword)
     (lambda (x) (if (string= (upcase keyword) (org-element-property :key x))
                  (list (org-element-property :value x)) )
       )
     ) delimiter))

    (defun link (linkString)
        (save-excursion
        (search-backward (concat "[" linkString "]]"))
        (search-backward "[")
        (search-forward ":")
        (let ((begin (point)))
            (search-forward "]")
            (forward-char -1)
            (buffer-substring-no-properties begin (point))
    )))

    (defun head () (save-excursion
        (search-backward-regexp "^\\* ")
        (evil-forward-word-begin)
        (buffer-substring-no-properties (point) (point-at-eol))
    ))

    (defun from (table key)
      (mapconcat (lambda (x) (if (string= (pop x) key) (mapconcat 'identity x " | ") "")) table ""))

)
#+end_src
**** special functions
#+begin_src elisp
(use-package! ox
    :defer t
    :commands
    graph
    :config
    (defun graph ()
        (save-excursion
        (search-backward "*")
        (evil-forward-word-begin)
        (setq drawGraphName (buffer-substring-no-properties (point) (point-at-eol)))
        (evil-next-line-first-non-blank)
        ;; (if (string= (thing-at-point 'line t) "#+begin_src txt :exports none\n")
            (evil-next-line-first-non-blank)
        ;; (spacemacs/insert-line-above-no-indent 1)
        ;; (evil-previous-line-first-non-blank)
        ;; (insert "#+begin_src txt :exports none")
        ;; (evil-next-line-first-non-blank)
        ;; )
        (let ((begin (point)))
        (search-forward "(graph)")
        (evil-previous-line-first-non-blank)
        ;; (if (string= (thing-at-point 'line t) "#+end_src\n")
            (previous-line)
            ;; (spacemacs/insert-line-below-no-indent 1)
            ;; (evil-next-line-first-non-blank)
            ;; (insert "#+end_src")
            ;; (evil-previous-line-first-non-blank)
            ;; )
        (setq drawGraph (buffer-substring-no-properties begin (point-at-eol)))
        )
        (concat drawGraph (concat "\nname: " (replace-regexp-in-string " " "_" (replace-regexp-in-string " *:.*" "" drawGraphName))))
        )
        )
    )
#+end_src
**** markup =_/
#+begin_src elisp
(use-package! ox
    :defer t
    :custom
    (org-latex-text-markup-alist '(
     (bold . "\\textbf{%s}")
     (code . protectedtexttt)
     (italic . "\\emph{%s}")
     (strike-through . "\\sout{%s}")
     (underline . "\\uline{%s}")
     (verbatim . "\\textsc{%s}")
     ))
    )
#+end_src
**** only and visible enviroment for beamer
#+begin_src elisp
(use-package! ox-beamer
  :defer t
  :config
  (add-to-list 'org-beamer-environments-extra
  '("onlyenv" "O" "\\begin{onlyenv}%a" "\\end{onlyenv}"))
  (add-to-list 'org-beamer-environments-extra
               '("visibleenv" "V" "\\begin{visibleenv}%a" "\\end{visibleenv}"))
  (add-to-list 'org-beamer-environments-extra
               '("overlayarea" "S" "\\begin{overlayarea}%a" "\\end{overlayarea}"))
  )
#+end_src
**** babel
#+begin_src elisp
(use-package! ox
      :defer t
      :commands evalBlock pick-date
      :custom
      (org-confirm-babel-evaluate nil)
      (org-babel-default-header-args '(
        (:eval . "never-export")
        (:noweb . "yes")
        (:session . "none")
        (:results . "replace")
        (:exports . "code")
        (:cache . "no")
        (:hlines . "no")
        (:tangle . "no")
      ))
      :config
      (add-hook 'org-export-before-processing-hook #'org-babel-tangle)
      (org-babel-do-load-languages
      'org-babel-load-languages
      '(
        (emacs-lisp . t)
        (latex . t)
        (shell . t)
        (python . t)
        (dot . t)
        ))

    (defun evalBlock (name)
      (save-excursion
        (org-babel-goto-named-src-block name)
        (org-babel-execute-src-block)))

    (defun pick-date ()
        (org-format-time-string "%Y-%m-%d %A"
         (org-read-date nil t)
    ))
  )
#+end_src
**** export to multiple pdfs
#+begin_src elisp
  (use-package! ox
    :commands org-export-headlines-to-pdf
    :config
    (defun org-export-headlines-to-pdf ()
        "Export all subtrees that are *not* tagged with :noexport: to
    separate files.

    Subtrees that do not have the :EXPORT_FILE_NAME: property set
    are exported to a filename derived from the headline text."
        (interactive)
        (save-buffer)
        (let (
            (modifiedp (buffer-modified-p))
            ;; (pdfs "pdfs")
            (pdfs "")
            )
        (unless (or (string= pdfs "") (file-exists-p pdfs))
            (make-directory pdfs))
        (save-excursion
            (goto-char (point-min))
            (goto-char (re-search-forward "^*"))
            (set-mark (line-beginning-position))
            (goto-char (point-max))
            (org-map-entries
            (lambda ()
            (let ((export-file (org-entry-get (point) "EXPORT_FILE_NAME")))
                (unless export-file
                (org-set-property
                    "EXPORT_FILE_NAME"
                    (concat pdfs (if (string= pdfs "") "" "/") (replace-regexp-in-string "," ""
                                            (replace-regexp-in-string " " "_" (nth 4 (org-heading-components)))))
                    ))
                (deactivate-mark)
                (org-latex-export-to-pdf nil t)
                (unless export-file (org-delete-property "EXPORT_FILE_NAME"))
                (set-buffer-modified-p modifiedp)))
            "-noexport" 'region-start-level))
        (shell-command (concat "find " pdfs " -type f -name \"*.tex\" -delete"))
        )))
#+end_src
**** align tables after executing code blocs
#+begin_src elisp
(defadvice! format-table-execute (&rest _)
  :after #'org-babel-execute-buffer
  (org-table-map-tables 'org-table-align)
  )
#+end_src
**** edit ipe
#+begin_src elisp
(map! :leader :map org-mode-map "oi" 'editIpe)
(use-package! ox
    :defer t
    :commands editIpe
    :config
    (defun editIpe()
    (interactive)
    (save-excursion
      (forward-char 1)
      (search-backward "[")
      (search-forward ":")
      (shell-command  (concat "ipe " (let ((a (point)))
        (search-forward "]")
        (backward-char 1)
        (buffer-substring-no-properties a (point))
        ))))))
#+end_src
**** goto block
#+begin_src elisp
(map! :map org-mode-map :n "gb" 'gotoBlock)
(use-package! org
    :defer t
    :commands gotoBlock
    :config
    (defun gotoBlock ()
     (interactive)
     (evil-first-non-blank)
     (evil-forward-WORD-begin)
     (when (string= "" (thing-at-point 'word t)))
     (search-forward (concat "#+name: "(thing-at-point 'word t)) )
     ))
#+end_src
**** library of babel
#+begin_src elisp
(use-package! ox
    :defer t
    :config
    (org-babel-lob-ingest "~/emacs/babel.org")
)
#+end_src
**** view pdf
#+begin_src elisp
(use-package org-pdftools
  :hook (org-mode . org-pdftools-setup-link))
(use-package! ox
    :defer t
    :config
    (map! :mode org-mode :leader "ov" 'org-pdf-view)
    (defun org-pdf-view ()
        (interactive)
        (let ((pdf (replace-regexp-in-string ".org" ".pdf" (buffer-file-name)) ))
        (find-file pdf)
        ))
)
#+end_src
**** tags export bold
#+begin_src elisp
(use-package ox-latex
  :defer t
  :config
    (defun org-latex-format-headline-default-function
      (todo _todo-type priority text tags _info)
    "Default format function for a headline.
  See `org-latex-format-headline-function' for details."
    (concat
      (and todo (format "{\\bfseries\\sffamily %s} " todo))
      (and priority (format "\\framebox{\\#%c} " priority))
      text
      (and tags
    (format "\\hfill{}\\textbf{%s}"
            (mapconcat #'org-latex--protect-text tags ":")))))
  )
#+end_src
** dired
*** keybindings
#+begin_src elisp
(map! :after dired
   :map dired-mode-map
   :n "s" 'dired-mark
   :n "m" 'evil-set-marker
   :n "j" 'evil-goto-mark
   :n "q" 'evil-record-macro
   )
#+end_src
** elisp
*** asynce shell
#+begin_src elisp
(defun call (cmd)
    (call-process-shell-command cmd nil 0)
    )
#+end_src
*** command by key
#+begin_src elisp
(map! :leader "hK" 'insertCommandByKey)
(use-package! help :commands insertCommandByKey
  :config
  (defun insertCommandByKey ()
    (interactive)
    (insert (replace-regexp-in-string ".*runs the command " ""
                                            (call-interactively 'describe-key-briefly)))))
#+end_src
*** macro to lisp
#+begin_src elisp
(map! :leader "im" 'macroToLisp)
(use-package! kmacro :commands macroToLisp
  :config
  (defun macroToLisp()
    (interactive)
    (name-last-kbd-macro (intern "tolisp"))
    (evil-open-below 1)
    (insert (concat "(execute-kbd-macro "
                    (with-temp-buffer
        (insert-kbd-macro (intern-soft "tolisp"))
        (goto-char (point-min))
        (search-forward "[")
        (let ((a (- (point) 1)))
        (search-forward "]")
        (buffer-substring-no-properties a (point))
        )
        )")" ))
    (evil-normal-state)
    (evil-first-non-blank)
  ) )
#+end_src
*** run on buffer copy
#+begin_src elisp
(use-package! kmacro :commands runOnBuffer
  :config
  (defun runOnBuffer (macro &optional try)
    "Edits string and returns it"
    (clipboard-kill-ring-save (point-min) (point))
    (let ((this-buffer (buffer-name))
          (buffy "*edit-string*"))
      (save-excursion
        (switch-to-buffer buffy)
        (set-buffer buffy)
        (erase-buffer)
        (yank)
        (funcall macro)
        ;; (setq new-value (buffer-substring-no-properties (point-min) (point-max)))
        (setq new-value (thing-at-point 'line t))
        (unless try
          (kill-buffer buffy)
          (switch-to-buffer this-buffer)
        )
        new-value))))
#+end_src
*** eval and replace
#+begin_src elisp
(map! :leader "iR" 'eval-and-replace)
(use-package! elisp-mode
  :commands eval-and-replace
  :config
    (defun eval-and-replace ()
    (interactive)
    (search-forward ")")
    (let ((value (eval (preceding-sexp))))
        (kill-sexp -1)
        (if (stringp value)
            (insert (substring (format "%S" value) 1 -1 ))
        (insert (format "%S" value))
        )
    )))
#+end_src

#+RESULTS:
: t

** eshell
*** commands
#+begin_src elisp
(use-package! eshell
  :defer t
  :config
  (defalias 'ff 'find-file)

  (defun eshell/ll ()
    (find-file ".")
    )

  (defun sq (a &optional b)
      (if b
          (number-sequence a
                          (- b 1))
      (number-sequence 0
                      (- a 1))))

  (defun eshell/take (&rest args)
      (let ((dir (pop args)))
      (mkdir dir)
      (cd dir)))

  (defun eshell/extract (&rest args)
      (eshell-command (concat "zsh -i -c \"extract "
                              (car args)
                              "\" > #<*extract*>")))

  (defun eshell/lsp (&rest args)
      (mkdir "build" t)
      (cd "build")
      (eshell-command "cmake ..")
      (eshell-command "cmake -H. -BDebug -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=YES ..")
      ;; (eshell-command "make")
      (cd "..")
      (eshell-command "ln -s build/Debug/compile_commands.json .")
      )

  (defun eshell/lspmake (&rest args)
      (eshell-command "bear -- make")
      )

  (defun eshell/list (&rest args)
      (eshell-command-result (concat
      "find " (pop args) " -name " (pop args) " -exec readlink -f {} \\; | sort"
      )))

  (defun eshell/c (&rest args)
      (eshell-command (concat
                      "tar cfJ "
                      (replace-regexp-in-string (regexp-quote "/") "" (car args) nil 'literal)
                      ".tar.xz "
                      (car args)
                      )))

  (defun eshell/uc (&rest args)
      (eshell-command (concat
                      "tar xf "
                      (car args)
                      )))

  (defun eshell/lspwd (&rest args)
  (eshell-command-result "ls -d $PWD/*"))

  (defun eshell/take (&rest args)
      (let ((dir (pop args)))
      (mkdir dir)
      (cd dir)))
)
#+end_src
*** aliases
#+begin_src elisp
(after! eshell (set-eshell-alias!
    "get"  "sudo pacman -S $*"
    ))
#+end_src
*** keybindings
#+begin_src elisp
(map! :after eshell :mode eshell-mode
      :n "<return>" 'eshell-send-input
      :n "<tab>"    'eshell-previous-fix
      :n "<insert>" 'eshell-next-fix
      :leader "ae" '+eshell/frame
      )
(use-package! eshell
  :commands
  eshell-previous-fix
  eshell-next-fix
  :config
  (defun eshell-previous-fix()
    (interactive)
    (evil-append 1)
    (insert " ")
    (evil-normal-state)
    (call-interactively 'eshell-previous-input)
    )
  (defun eshell-next-fix ()
    (interactive)
    (evil-append 1)
    (insert " ")
    (evil-normal-state)
    (call-interactively 'eshell-next-input)
    ))
#+end_src

*** setting
#+begin_src elisp
(use-package! eshell
  :custom
  (+eshell-config-dir "~/emacs/eshell/")
  :config
    (defadvice! synchronisly-write-history (&rest _)
    :after #'eshell-send-input
    (eshell-write-history)
    )
)
#+end_src
*** vterm
#+begin_src elisp
(use-package! vterm
  :commands vterm/frame
  :config
  (defun vterm/frame ()
  (interactive)
  (vterm)
  (delete-other-windows)))
#+end_src
** latex
*** keybindings
#+begin_src elisp
(map! :after latex :map evil-tex-mode-map
      :n "m" 'evil-set-marker
      )
#+end_src
** speed type
#+begin_src elisp
(map! :leader "os" 'speed-type-text
              "oS" 'speed-type--replay
      )
(use-package! speed-type
  :commands speed-type-text)
#+end_src
* temp