About
To fix
https://dev.to/viglioni/how-i-set-up-my-emacs-for-typescript-3eeh https://github.com/clemera/helm-ido-like-guide
Introduction
A personal setup, based on my init file generator tool.
Licence
Copyright (C) 2020 Arthur Miller
Author: Arthur Miller <arthur.miller@live.com>
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.
Generator
(defvar init-file-bake-autoloads t)
(defvar init-file-verbose-messages nil)
(defvar init-file-unroll-key-bindings t)
(defvar init-file-use-modules nil)
(defvar init-file-modules-directory (expand-file-name "elc-cache/" user-emacs-directory))
(defvar init-file-lisp-directory (expand-file-name "lisp/" user-emacs-directory))
(defvar init-file-source-repositories (list package-user-dir init-file-lisp-directory))
(defvar init-file--autoloads-map (make-hash-table :test 'equal))
(defvar init-file--loadpaths-map (make-hash-table :test 'equal))
(require 'package)
(setq package-archives nil)
(defvar site-archive '("local" . "/home/arthur/repos/"))
(defvar org-archive '("org" . "https://orgmode.org/elpa/"))
(defvar gnu-archive '("elpa" . "https://elpa.gnu.org/packages/"))
(defvar melpa-archive '("melpa" . "https://melpa.org/packages/"))
(defvar nelpa-archive '("nelpa" . "https://elpa.nongnu.org/nongnu/"))
(defvar marmalade-archive '("marmalade" . "https://marmalade-repo.org/packages/"))
(add-to-list 'package-archives site-archive)
(add-to-list 'package-archives org-archive)
(add-to-list 'package-archives gnu-archive)
(add-to-list 'package-archives nelpa-archive)
(add-to-list 'package-archives melpa-archive)
;;(add-to-list 'package-archives marmalade-archive)
(setq package-archives (nreverse package-archives))
(unless (file-directory-p init-file-modules-directory)
(make-directory init-file-modules-directory))
(unless (boundp 'init-file-hooks)
(make-variable-buffer-local 'init-file-hooks))
(unless (boundp 'init-file-package-list)
(make-variable-buffer-local 'init-file-package-list))
(defun on-buffer-change-hook (beg eng len)
(setq init-file-package-list nil))
(add-hook 'after-change-functions 'on-buffer-change-hook)
(defmacro with-hook (name &rest body)
(let (found hook)
(setq name (if (string-match "-hook\\'" (symbol-name `,name))
`,name
(intern (concat (symbol-name name) "-hook"))))
(setq body (nreverse body))
(dolist (hook init-file-hooks)
(when (equal (symbol-name (car hook)) (symbol-name name))
(dolist (sexp (nreverse (cdr hook)))
(add-to-list 'body sexp))
(setcdr hook body)
(setq found t)))
(unless found
(add-to-list 'init-file-hooks (cons name body)))
(ignore)))
(defmacro verbose (format-string &rest args )
(when init-file-verbose-messages
`(message ,format-string ,@args)))
(defun clean-init-file ()
(interactive)
(with-temp-buffer
(insert-file-contents "init.el")
(beginning-of-buffer)
(while (not (eobp))
(when (char-equal (char-after) ?\^M)
(delete-char 1))
(forward-char 1))
(write-region (point-min) (point-max) "init.el")))
(defmacro after-load (name &rest body)
(with-eval-after-load name
`(progn ,@body)))
(defmacro with-package (name &rest body)
(verbose "Parsing package %s" name)
(let ((package (symbol-name name)))
(append-to-init-file "(with-eval-after-load ")
(append-to-init-file (concat "'" package "\n "))
(emit-to-init-file body)
(append-to-init-file ")\n")))
(defmacro when-idle (&rest body)
`(run-with-idle-timer 0.5 nil (lambda () ,@body)))
(defmacro with-system (systype &rest body)
(if (equal system-type systype)
`(progn ,@body)))
(defmacro with-host (host &rest body)
(if (equal system-name host)
`(progn ,@body)))
(defmacro defkeys (mapname &rest body)
`(let ((defs '(,@body)))
(while defs
(define-key ,mapname
(if (vectorp (car defs))
(car defs)
(read-kbd-macro (car defs)))
(if (or (listp (cadr defs)) (functionp (cadr defs)))
(cadr defs)
(if `(keymapp (bound-and-true-p ,(cadr defs)))
(eval (cadr defs)))))
(setq defs (cddr defs)))))
(defun emit-defkeys (map keys)
(while keys
(append-to-init-file
(concat "(define-key " (symbol-name map) " "
(if (vectorp (car keys))
(prin1-to-string (car keys))
(concat "(kbd \"" (car keys) "\")"))
" #'" (prin1-to-string (cadr keys))
")"))
(setq keys (cddr keys))))
(defun emit-when-idle (sexp)
(append-to-init-file
(format "(run-with-idle-timer 0.5 nil (lambda () %s))" sexp)))
(defun append-to-init-file (data &optional file)
(unless file (setq file "init.el"))
(let (insert-point)
(cond ((stringp data)
(write-region data nil file t 0))
((bufferp data)
(with-current-buffer data
(write-region (point-min) (point-max) file t 0))))))
(defun emit-sexp-to-init-file (sexp)
(if init-file-unroll-key-bindings
(cond ((equal (car sexp) 'defkeys)
(emit-defkeys (cadr sexp) (cddr sexp)))
((equal (car sexp) 'with-system)
(when (equal (cadr sexp) system-type)
(emit-to-init-file (cddr sexp))))
((equal (car sexp) 'when-idle)
(emit-when-idle (cadr sexp)))
(t
(append-to-init-file (prin1-to-string sexp))))
(append-to-init-file (prin1-to-string sexp))))
(defun emit-to-init-file (&rest body)
(dolist (sexp body)
(if (listp (car sexp))
(dolist (s sexp)
(emit-sexp-to-init-file s))
(emit-sexp-to-init-file sexp))))
(defun emit-packages ()
(message "Emiting packages ...")
(dolist (p (get-package-list))
(verbose "Checking package: %s" (aref p 0))
(when (package-enabled-p p)
(verbose "Emiting package: %s" (aref p 0))
(eval-region (aref p 4) (aref p 5)))))
(defun emit-hooks ()
(message "Emiting hooks ...")
(dolist (hook init-file-hooks)
(verbose "Hook: %s" (car hook))
(if (equal (symbol-name (car hook)) "early-init-hook")
(dolist (elt (nreverse (cdr hook)))
(append-to-init-file (prin1-to-string elt) "early-init.el"))
(progn
(append-to-init-file (concat "(add-hook '"
(symbol-name (car hook))
" #'(lambda nil\n"))
(dolist (s (cdr hook))
(emit-to-init-file s))
(append-to-init-file "))")))))
(defun get-load-paths()
(let ((elpa (expand-file-name "elpa" user-emacs-directory))
(archives (expand-file-name "elpa/archives" user-emacs-directory))
package-paths)
(dolist (path (directory-files elpa t directory-files-no-dot-files-regexp))
(when (file-directory-p path)
(unless (string= path archives)
(push path package-paths))))
(push init-file-lisp-directory package-paths)
package-paths))
(defun emit-load-paths ()
(message "Emitting load-path")
(append-to-init-file (concat "\n(nconc load-path '"
(prin1-to-string (get-load-paths))
")\n")
"early-init.el"))
(defun quoted (sym)
(if (and (consp sym) (eq (car sym) 'quote))
sym `(quote ,sym)))
(defun collect-autoloads (src index)
(let (sxp sym)
(with-current-buffer (get-buffer-create "*ql-buffer*")
(erase-buffer)
(insert-file-contents src)
(goto-char (point-min))
(while (re-search-forward "^;;;###autoload" nil t)
(setq sxp nil sym nil)
(setq sxp (ignore-errors (read (current-buffer))))
(when (listp sxp)
(setq sym (quoted (cadr sxp)))
(unless (listp (cadr sym))
(puthash sym index init-file--autoloads-map)))))))
(defun generate-autoloads (dir-tree-or-dir-tree-list &optional outfile)
(let ((index 0) srcs
(tofile (or outfile (expand-file-name "autoloads.el" user-emacs-directory))))
(if (listp dir-tree-or-dir-tree-list)
(dolist (dir-tree dir-tree-or-dir-tree-list)
(setq srcs (nconc srcs (directory-files-recursively dir-tree "\\.el$"))))
(setq srcs (directory-files-recursively dir-tree-or-dir-tree-list "\\.el$")))
(dolist (src srcs)
(unless (or (string-match-p src "-pkg\\.el")
(string-match-p src "-autoload\\.el"))
(puthash index (file-name-sans-extension src) init-file--loadpaths-map)
(collect-autoloads src index))
(setq index (1+ index)))
(with-temp-file tofile
(maphash (lambda (symbol index)
(let ((path (file-name-nondirectory (gethash index init-file--loadpaths-map))))
(prin1 `(autoload ,symbol ,path)
(current-buffer))
(insert "\n"))) init-file--autoloads-map))
(kill-buffer (get-buffer-create "*ql-buffer*"))))
(defun emit-autoloads ()
(message "Emiting autoloads")
(let ((al (expand-file-name "autoloads.el" user-emacs-directory)))
(unless (file-exists-p al)
(verbose "Generating autoloads: %s" al)
(generate-autoloads init-file-source-repositories))))
(defmacro maybe-remove-file (file)
`(when (file-exists-p ,file)
(delete-file ,file)
(message "Removed file %s" ,file)))
(defun tangle-init-file (&optional file)
(message "Exporting init files.")
(unless file
(setq file "init.el"))
(maybe-remove-file "init.el")
(maybe-remove-file "init.elc")
(maybe-remove-file "early-init.el")
(with-temp-file "init.el"
(insert ";; init.el -*- lexical-binding: t; -*-\n")
(insert ";; This file is machine generated by init-file generator, don't edit\n")
(insert ";; manually, edit instead file init.org and generate new init file from it.\n\n"))
(with-temp-file "early-init.el"
(insert ";; early-init.el -*- lexical-binding: t; -*-\n")
(insert ";; This file is machine generated by init-file generator, don't edit\n")
(insert ";; manually, edit instead file init.org and generate new init file from it.\n\n"))
(setq init-file-hooks nil)
;; are we baking quickstart file?
(when init-file-bake-autoloads
(emit-autoloads)
(with-temp-buffer
(insert-file-contents-literally "autoloads.el")
(append-to-init-file (current-buffer))))
;; generate stuff
(emit-packages)
;; do this after user init stuff
(emit-hooks) ;; must be done after emiting packages
(emit-load-paths);; must be done after emiting hooks
;; fix init.el
(append-to-init-file "\n;; Local Variables:\n")
(append-to-init-file ";; byte-compile-warnings: '(not docstrings free-vars))\n")
(append-to-init-file ";; End:\n")
(clean-init-file))
(defun goto-code-start (section)
(goto-char (point-min))
(re-search-forward section)
(re-search-forward "begin_src.*emacs-lisp")
(skip-chars-forward "\s\t\n\r"))
(defun goto-code-end ()
(re-search-forward "end_src")
(beginning-of-line))
(defun generate-init-files ()
(interactive)
(message "Exporting init.el ...")
(tangle-init-file)
(setq byte-compile-warnings nil)
(let ((tangled-file "init.el")
(byte-compile-warnings nil)
(fill-column 240))
;; always produce elc file
(byte-compile-file tangled-file)
(verbose "Byte compiled %s" tangled-file)
(if (featurep 'comp)
(message "Native compiled %s" (native-compile tangled-file)))
(verbose "Tangled and compiled %s" tangled-file))
(verbose "Done.")
(message "Compiling early-init.el ...")
(byte-compile-file (expand-file-name "early-init.el" user-emacs-directory))
(message "Done."))
(defun install-file (file)
(when (file-exists-p file)
(unless (equal (file-name-directory buffer-file-name)
(expand-file-name user-emacs-directory))
(copy-file file user-emacs-directory t))
(message "Wrote: %s." file)))
(defun install-init-files ()
(interactive)
(let ((i "init.el")
(ic "init.elc")
(ei "early-init.el")
(al "autoloads.el")
(pq (expand-file-name "package-quickstart.el" user-emacs-directory))
(pqc (expand-file-name "package-quickstart.elc" user-emacs-directory)))
(install-file i)
(install-file ei)
(unless (file-exists-p ic)
(byte-compile (expand-file-name el)))
(install-file ic)
(unless init-file-bake-autoloads
(byte-compile pq))
(when init-file-bake-autoloads
;; remove package-quickstart files from .emacs.d
(when (file-exists-p pq)
(delete-file pq))
(when (file-exists-p pqc)
(delete-file pqc)))))
(defmacro gt (n1 n2)
`(> ,n1 ,n2))
(defmacro gte (n1 n2)
`(>= ,n1 ,n2))
(defmacro lt (n1 n2)
`(< ,n1 ,n2))
(defmacro lte (n1 n2)
`(<= ,n1 ,n2))
(defun package-name (package)
(aref package 0))
(defun package-enabled-p (package)
(aref package 1))
(defun package-pseudo-p (package)
(aref package 2))
(defun package-pinned-to (package)
(aref package 3))
(defun package-code-beg (package)
(aref package 4))
(defun package-code-end (package)
(aref package 5))
(defun get-package-list ()
(when (buffer-modified-p)
(setq init-file-package-list nil))
(unless init-file-package-list
(save-excursion
(goto-char (point-min))
(let (package packages start end
config-start config-end ms me s)
(goto-char (point-min))
(verbose "Creating package list ...")
(re-search-forward "^\\* Packages")
(while (re-search-forward "^\\*\\* " (eobp) t)
;; format: [name enabled pseudo pinned-to code-start-pos code-end-pos fetch-url]
(setq package (vector "" t nil "" 0 0 "")
config-start (point) end (line-end-position))
;; package name
(while (search-forward "] " end t) )
(setq start (point))
(skip-chars-forward "[a-zA-Z\\-]")
(aset package 0
(buffer-substring-no-properties start (point)))
(goto-char (line-beginning-position))
;; enabled?
(when (search-forward "[ ]" end t)
(aset package 1 nil))
(goto-char (line-beginning-position))
(search-forward "[" end t)
(setq ms (point))
(goto-char (line-beginning-position))
(search-forward "]" end t)
(setq me (- (point) 1))
(setq s (buffer-substring-no-properties ms me))
(when (gt (length s) 1)
(setq s (string-trim s))
;; installable?
(if (or (equal s "local") (equal s "none"))
(aset package 2 t)
;; pinned to repository?
(aset package 3 s)))
(goto-char start)
;; code start
(re-search-forward "begin_src.*emacs-lisp" (eobp) t)
(aset package 4 (point))
(re-search-forward "end_src$" (eobp) t)
(beginning-of-line)
(aset package 5 (- (point) 1))
;; are we fetching from somewhere?
(goto-char (aref package 5))
(when (re-search-backward "^[ \t].*GIT:" config-start t)
(search-forward "GIT:")
(skip-chars-forward " \t")
(setq start (point))
(end-of-line)
(skip-chars-backward " \t")
(aset package 6
(buffer-substring-no-properties start (point))))
(push package init-file-package-list)
(setq init-file-package-list (nreverse init-file-package-list))))))
init-file-package-list)
;; Install packages
(defun ensure-package (package)
(let ((p (intern (aref package 0))))
(unless (package-installed-p p)
(message "Installing package: %s" p)
(package-install p))))
(defun install-packages (&optional packages)
(interactive)
(package-initialize)
(package-refresh-contents)
(unless packages
(setq packages (get-package-list)))
(dolist (p packages)
(unless (package-pseudo-p p)
(unless (string-empty-p (aref p 3))
(add-to-list 'package-pinned-packages (cons (intern (aref p 0)) (aref p 3))))
(ensure-package p))))
(defun current-package ()
"Return name of package the cursor is at the moment."
(save-excursion
(let (nb ne pn (start (point)))
(when (re-search-backward "^\\* Packages" (point-min) t)
(setq nb (point))
(goto-char start)
(setq pn (search-forward "** " (line-end-position) t 1))
(unless pn
(setq pn (search-backward "** " nb t 1)))
(when pn
(search-forward "] ")
(setq nb (point))
(re-search-forward "[\n[:blank:]]")
(forward-char -1)
(setq ne (point))
(setq pn (buffer-substring-no-properties nb ne))
pn)))))
(defun install-and-configure ()
(interactive)
(install-packages)
(generate-init-files)
(install-init-files))
(defun configure-emacs ()
(interactive)
(generate-init-files)
(install-init-files))
;;; org hacks
(if (featurep 'org-heading-checkbox)
(unload-feature 'org-heading-checkbox))
(defvar org-init--enabled-re "^[ \t]*\\*+.*?[ \t]*\\[x\\]")
(defvar org-init--disabled-re "^[ \t]*\\*+.*?[ \t]*\\[ \\]")
(defvar org-init--checkbox-re "^[ \t]*\\*+.*?\\[[ x]\\]")
(defun org-init--heading-checkbox-p ()
"Return t if this is a heading with a checkbox."
(save-excursion
(beginning-of-line)
(looking-at org-init--checkbox-re)))
(defun org-init--checkbox-enabled-p ()
"Return t if point is at a heading with an enabed checkbox."
(save-excursion
(beginning-of-line)
(looking-at "^[ \t]*\\*+.*?\\[x\\]")))
(defun org-init--checkbox-disabled-p ()
"Return t if point is at a heading with a disabeled checkbox."
(save-excursion
(beginning-of-line)
(looking-at "^[ \t]*\\*+.*?\\[ \\]")))
(defun org-init--checkbox-enable ()
"Disable checkbox for heading at point."
(interactive)
(when (org-init--checkbox-enabled-p)
(save-excursion
(beginning-of-line)
(replace-string "[ ]" "[x]" nil (line-beginning-position)
(line-end-position)))))
(defun org-init--checkbox-disable ()
"Disable checkbox for heading at point."
(interactive)
(when (org-init--checkbox-enabled-p)
(save-excursion
(beginning-of-line)
(replace-string "[x]" "[ ]" nil (line-beginning-position)
(line-end-position)))))
(defun org-init--checkbox-toggle ()
"Toggle state of checkbox at heading under the point."
(interactive)
(save-excursion
(beginning-of-line)
(cond ((looking-at org-init--enabled-re)
(replace-string "[x]" "[ ]" nil (line-beginning-position)
(line-end-position)))
((looking-at org-init--disabled-re)
(replace-string "[ ]" "[x]" nil (line-beginning-position)
(line-end-position)))
(t (error "Not at org-init-checkbox line.")))))
(defun org-init--packages ()
"Return start of packages; point after the \"* Packages\" heading."
(save-excursion
;; we search backward, which will find beginning of line if the current
;; point is after the heading
(cond ((re-search-backward "^\\* Packages" (point-min) t)
(point))
;; the point was after the heading, and now we are at the point-min
((re-search-forward "^\\* Packages" nil t)
(beginning-of-line)
(point))
;; we didn't found the Packages section, means invalid file
(t (error "No Packages section in current file found.")))))
;; help fns to work with init.org
(defun add-package (package)
(interactive "sPackage name: ")
(goto-char (org-init--packages))
(forward-line 1)
(insert (concat "\n** [x] "
package
"\n#+begin_src emacs-lisp\n"
"\n#+end_src\n"))
(forward-line -2))
(defun add-git-package (url)
(interactive "sGIT url: ")
(unless (string-empty-p url)
(let ((tokens (split-string url "/" t "\s\t")) package)
(message "T: %S" tokens)
(dolist (tk tokens)
(setq package tk))
(goto-char (org-init--packages))
(forward-line 1)
(insert (concat "\n** [x] " package
"\n#+GIT: " url
"\n#+begin_src emacs-lisp\n"
"\n#+end_src\n"))
(forward-line -2))))
(defun add-pseudo-package (package)
(interactive "sPackage name: ")
(goto-char (org-init--packages))
(forward-line 1)
(insert (concat "** [none ] [x] "
package
"\n#+begin_src emacs-lisp\n"
"\n#+end_src\n"))
(forward-line -2))
(defun org-init--package-enabled-p ()
"Return t if point is in a package headline and package is enabled."
(save-excursion
(beginning-of-line)
(looking-at "^[ \t]*\\*\\* \\[x\\]")))
(defun org-init--toggle-headline-checkbox ()
"Switch between enabled/disabled todo state."
(if (org-init--package-enabled-p)
(org-todo 2)
(org-todo 1)))
(defun org-init--package-section-p ()
(save-excursion
(let ((current-point (point)))
(when (re-search-backward "^\\* Packages" nil t)
(forward-line 1)
(gte current-point (point))))))
(defun org-init--shiftup ()
"Switch between enabled/disabled todo state."
(interactive)
(if (org-init--package-section-p)
(save-excursion
(beginning-of-line)
(unless (looking-at org-heading-regexp)
(re-search-backward org-heading-regexp))
(if (org-init--heading-checkbox-p)
(org-init--checkbox-toggle)))
(org-shiftup)))
(defun org-init--shiftdown ()
"Switch between enabled/disabled todo state."
(interactive)
(if (org-init--package-section-p)
(save-excursion
(beginning-of-line)
(unless (looking-at org-heading-regexp)
(re-search-backward org-heading-regexp))
(if (org-init--heading-checkbox-p)
(org-init--checkbox-toggle)))
(org-shiftdown)))
(defun org-init--shiftright ()
"Switch between enabled/disabled todo state."
(interactive)
(if (org-init--package-section-p)
(save-excursion
(beginning-of-line)
(unless (looking-at org-heading-regexp)
(re-search-backward org-heading-regexp))
(org-shiftright))
(org-shiftright)))
(defun org-init--shiftleft ()
"Switch between enabled/disabled todo state."
(interactive)
(if (org-init--package-section-p)
(save-excursion
(beginning-of-line)
(unless (looking-at org-heading-regexp)
(re-search-backward org-heading-regexp))
(org-shiftleft))
(org-shiftleft)))
(defun org-init--open-in-dired ()
(interactive)
(if (org-init--package-section-p)
(save-excursion
(beginning-of-line)
(unless (looking-at org-heading-regexp)
(re-search-backward org-heading-regexp))
(let ((elpa (expand-file-name "elpa" user-emacs-directory))
start pkgname pkdir)
(search-forward "[ " (line-end-position) t)
(if (search-forward "none" (line-end-position) t)
(dired (expand-file-name "lisp/" user-emacs-directory) pkdir)
(progn
(beginning-of-line)
(while (search-forward "] " (line-end-position) t) )
(setq start (point))
(skip-chars-forward "[a-zA-Z\\-]")
(setq pkgname (buffer-substring-no-properties start (point)))
(setq pkdir (directory-files elpa t pkgname t ))
(if pkdir (dired (car pkdir)))))))))
(defun org-init--sort-packages ()
"This is just a convenience wrapper for org-sort. It does reverted sort on
todo keywords-"
(interactive)
(save-excursion
(goto-char (org-init--packages))
(org-sort-entries nil ?a) ;; first sort alphabetic than in reversed todo-order
(org-sort-entries nil ?O)
(org-cycle) (org-cycle)))
(defun org-init--goto-package ()
(interactive)
(let ((org-goto-interface 'outline-path-completionp)
(org-outline-path-complete-in-steps nil))
(org-goto)))
(defvar org-init-mode-map
(let ((map (make-sparse-keymap)))
(define-key org-mode-map [remap org-shiftup] #'org-init--shiftup)
(define-key org-mode-map [remap org-shiftdown] #'org-init--shiftdown)
(define-key org-mode-map [remap org-shiftleft] #'org-init--shiftleft)
(define-key org-mode-map [remap org-shiftright] #'org-init--shiftright)
(define-key map (kbd "C-c C-j") 'org-init--open-in-dired)
(define-key map (kbd "C-c i j") 'org-init--goto-package)
(define-key map (kbd "C-c i a") 'add-package)
(define-key map (kbd "C-c i i") 'install-packages)
(define-key map (kbd "C-c i p") 'add-pseudo-package)
(define-key map (kbd "C-c i s") 'org-init--sort-packages)
(define-key map (kbd "C-c i g") 'generate-init-files)
map)
"Keymap used in `org-init-mode'.")
(defvar org-init-mode-enabled nil)
(defvar org-init-old-kwds nil)
(defvar org-init-old-key-alist nil)
(defvar org-init-old-kwd-alist nil)
(defvar org-init-old-log-done nil)
(defvar org-init-old-todo nil)
(setq org-init-mode-enabled nil org-init-old-kwds nil org-init-old-key-alist nil
org-init-old-kwd-alist nil org-init-old-log-done nil org-init-old-todo nil)
(make-variable-buffer-local 'org-log-done)
(make-variable-buffer-local 'org-todo-keywords)
(defun org-init--longest-str (lst)
(let ((len 0) l)
(dolist (elt lst)
(setq l (length elt))
(when (lt len l)
(setq len l)))
len))
(defun org-init--initial-outline ()
(save-excursion
(goto-char (point-min))
(re-search-forward "^\\* About")
(hide-subtree)
(re-search-forward "^\\* Generator")
(hide-subtree)
(re-search-forward "^\\* Packages")
(hide-subtree)
(show-children)))
(defun org-todo-per-file-keywords (kwds)
"Sets per file TODO labels. Takes as argument a list of strings to be
used as labels."
(let (alist)
(push "TODO" alist)
(dolist (kwd kwds)
(push kwd alist))
(setq alist (list (nreverse alist)))
;; TODO keywords.
(setq-local org-todo-kwd-alist nil)
(setq-local org-todo-key-alist nil)
(setq-local org-todo-key-trigger nil)
(setq-local org-todo-keywords-1 nil)
(setq-local org-done-keywords nil)
(setq-local org-todo-heads nil)
(setq-local org-todo-sets nil)
(setq-local org-todo-log-states nil)
(let ((todo-sequences alist))
(dolist (sequence todo-sequences)
(let* ((sequence (or (run-hook-with-args-until-success
'org-todo-setup-filter-hook sequence)
sequence))
(sequence-type (car sequence))
(keywords (cdr sequence))
(sep (member "|" keywords))
names alist)
(dolist (k (remove "|" keywords))
(unless (string-match "^\\(.*?\\)\\(?:(\\([^!@/]\\)?.*?)\\)?$"
k)
(error "Invalid TODO keyword %s" k))
(let ((name (match-string 1 k))
(key (match-string 2 k))
(log (org-extract-log-state-settings k)))
(push name names)
(push (cons name (and key (string-to-char key))) alist)
(when log (push log org-todo-log-states))))
(let* ((names (nreverse names))
(done (if sep (org-remove-keyword-keys (cdr sep))
(last names)))
(head (car names))
(tail (list sequence-type head (car done) (org-last done))))
(add-to-list 'org-todo-heads head 'append)
(push names org-todo-sets)
(setq org-done-keywords (append org-done-keywords done nil))
(setq org-todo-keywords-1 (append org-todo-keywords-1 names nil))
(setq org-todo-key-alist
(append org-todo-key-alist
(and alist
(append '((:startgroup))
(nreverse alist)
'((:endgroup))))))
(dolist (k names) (push (cons k tail) org-todo-kwd-alist))))))
(setq org-todo-sets (nreverse org-todo-sets)
org-todo-kwd-alist (nreverse org-todo-kwd-alist)
org-todo-key-trigger (delq nil (mapcar #'cdr org-todo-key-alist))
org-todo-key-alist (org-assign-fast-keys org-todo-key-alist))
;; Compute the regular expressions and other local variables.
;; Using `org-outline-regexp-bol' would complicate them much,
;; because of the fixed white space at the end of that string.
(unless org-done-keywords
(setq org-done-keywords
(and org-todo-keywords-1 (last org-todo-keywords-1))))
(setq org-not-done-keywords
(org-delete-all org-done-keywords
(copy-sequence org-todo-keywords-1))
org-todo-regexp (regexp-opt org-todo-keywords-1 t)
org-not-done-regexp (regexp-opt org-not-done-keywords t)
org-not-done-heading-regexp
(format org-heading-keyword-regexp-format org-not-done-regexp)
org-todo-line-regexp
(format org-heading-keyword-maybe-regexp-format org-todo-regexp)
org-complex-heading-regexp
(concat "^\\(\\*+\\)"
"\\(?: +" org-todo-regexp "\\)?"
"\\(?: +\\(\\[#.\\]\\)\\)?"
"\\(?: +\\(.*?\\)\\)??"
"\\(?:[ \t]+\\(:[[:alnum:]_@#%:]+:\\)\\)?"
"[ \t]*$")
org-complex-heading-regexp-format
(concat "^\\(\\*+\\)"
"\\(?: +" org-todo-regexp "\\)?"
"\\(?: +\\(\\[#.\\]\\)\\)?"
"\\(?: +"
;; Stats cookies can be stuck to body.
"\\(?:\\[[0-9%%/]+\\] *\\)*"
"\\(%s\\)"
"\\(?: *\\[[0-9%%/]+\\]\\)*"
"\\)"
"\\(?:[ \t]+\\(:[[:alnum:]_@#%%:]+:\\)\\)?"
"[ \t]*$")
org-todo-line-tags-regexp
(concat "^\\(\\*+\\)"
"\\(?: +" org-todo-regexp "\\)?"
"\\(?: +\\(.*?\\)\\)??"
"\\(?:[ \t]+\\(:[[:alnum:]:_@#%]+:\\)\\)?"
"[ \t]*$"))))
(push "GIT" org-element-affiliated-keywords)
;; from J. Kitchin:
;; https://kitchingroup.cheme.cmu.edu/blog/2017/06/10/Adding-keymaps-to-src-blocks-via-org-font-lock-hook/
(require 'org-mouse)
(require 'elisp-mode)
(defun scimax-spoof-mode (orig-func &rest args)
"Advice function to spoof commands in org-mode src blocks.
It is for commands that depend on the major mode. One example is
`lispy--eval'."
(if (org-in-src-block-p)
(let ((major-mode (intern (format "%s-mode"
(first (org-babel-get-src-block-info))))))
(apply orig-func args))
(apply orig-func args)))
(defvar scimax-src-block-keymaps
`(("emacs-lisp"
.
,(let ((map (make-composed-keymap
`(,emacs-lisp-mode-map ,org-init-mode-map)
org-mode-map)))
(define-key map (kbd "C-c C-c") 'org-ctrl-c-ctrl-c)
map))))
(defun scimax-add-keymap-to-src-blocks (limit)
"Add keymaps to src-blocks defined in `scimax-src-block-keymaps'."
(let ((case-fold-search t)
lang)
(while (re-search-forward org-babel-src-block-regexp limit t)
(let ((lang (match-string 2))
(beg (match-beginning 0))
(end (match-end 0)))
(if (assoc (org-no-properties lang) scimax-src-block-keymaps)
(progn
(add-text-properties
beg end `(local-map ,(cdr (assoc
(org-no-properties lang)
scimax-src-block-keymaps))))
(add-text-properties
beg end `(cursor-sensor-functions
((lambda (win prev-pos sym)
;; This simulates a mouse click and makes a menu change
(org-mouse-down-mouse nil)))))))))))
(define-minor-mode org-init-mode ""
:global nil :lighter " init-file"
(unless (derived-mode-p 'org-mode)
(error "Not in org-mode."))
(cond (org-init-mode
(unless org-init-mode-enabled
(setq org-init-mode-enabled t
org-init-old-log-done org-log-done
org-init-old-kwds org-todo-keywords-1
org-init-old-key-alist org-todo-key-alist
org-init-old-kwd-alist org-todo-kwd-alist)
(setq-local org-log-done nil)
(let (s kwdlist templist l)
(dolist (repo package-archives)
(push (car repo) templist))
(push "none" templist)
(setq l (org-init--longest-str templist))
(dolist (s templist)
(while (lt (length s) l)
(setq s (concat s " ")))
(push (concat "[ " s " ]") kwdlist))
(org-todo-per-file-keywords (nreverse kwdlist))))
(add-hook 'org-font-lock-hook #'scimax-add-keymap-to-src-blocks t)
(add-to-list 'font-lock-extra-managed-props 'local-map)
(add-to-list 'font-lock-extra-managed-props 'cursor-sensor-functions)
;;(advice-add 'lispy--eval :around 'scimax-spoof-mode)
(cursor-sensor-mode +1)
(eldoc-mode +1)
(company-mode +1))
(t
(remove-hook 'org-font-lock-hook #'scimax-add-keymap-to-src-blocks)
;;(advice-remove 'lispy--eval 'scimax-spoof-mode)
(cursor-sensor-mode -1)
(setq org-todo-keywords-1 org-init-old-kwds
org-todo-key-alist org-init-old-key-alist
org-todo-kwd-alist org-init-old-kwd-alist
org-log-done org-init-old-log-done
org-init-mode-enabled nil)))
(font-lock-fontify-buffer))
(org-init--initial-outline)
(org-init-mode +1)Packages
[x] rustic
[x] simple-httpd
[x] ace-window
(with-package ace-window
(ace-window-display-mode 1)
;;(setq aw-dispatch-always t)
(setq aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l)))[x] aggressive-indent
[x] all-the-icons
(with-package all-the-icons
(diminish 'all-the-icons-mode)
(setq neo-theme 'arrow)
(setq neo-window-fixed-size nil))[x] anaphora
[x] async
(with-package async
(async-bytecomp-package-mode 1)
(diminish 'async-dired-mode))[x] auto-package-update
(with-hook auto-package-update-after
(message "Refresh autoloads"))
(with-package auto-package-update
(setq auto-package-update-delete-old-versions t
auto-package-update-interval nil)
(defun apu--delete-old-versions-dirs-list ()
"Delete package old version dirs saved in variable apu--old-versions-dirs-list"
(dolist (old-version-dir-to-delete apu--old-versions-dirs-list)
(unless (file-symlink-p old-version-dir-to-delete)
(delete-directory old-version-dir-to-delete t)))
;; Clear list
(setq apu--old-versions-dirs-list ())))[x] auto-yasnippet
[x] avy
[x] beacon
(with-hook after-init
(when-idle
(beacon-mode t)
(diminish 'beacon-mode)))[x] borg
[x] bug-hunter
[x] bui
[x] cfrs
[x] cmake-font-lock
(with-hook prog-mode
;; Highlighting in cmake-mode this way interferes with
;; cmake-font-lock, which is something I dont yet understand.
(when (not (derived-mode-p 'cmake-mode))
(font-lock-add-keywords nil
'(("\\<\\(FIXME\\|TODO\\|BUG\\|DONE\\)"
1 font-lock-warning-face t)))))
(with-hook cmake-mode
(cmake-font-lock-activate))[x] cmake-mode
(with-hook after-init
(add-to-list 'auto-mode-alist '("\\.cmake\\'" . cmake-mode))
(add-to-list 'auto-mode-alist '("\\CMakeLists.txt\\'" . cmake-mode)))
(with-hook cmake
(require 'company)
(require 'company-cmake)
(company-mode 1))[x] company
(with-hook after-init
(add-hook 'c-mode-common-hook 'company-mode)
(add-hook 'sgml-mode-hook 'company-mode)
(add-hook 'emacs-lisp-mode-hook 'company-mode)
(add-hook 'text-mode-hook 'company-mode)
(add-hook 'lisp-mode-hook 'company-mode)
(when-idle
(require 'company)))
(with-package company
(require 'company-capf)
(require 'company-files)
(diminish 'company-mode)
(setq company-idle-delay 0.0
company-require-match nil
company-minimum-prefix-length 2
company-show-quick-access t
company-tooltip-limit 20
company-async-timeout 6
company-dabbrev-downcase nil
tab-always-indent 'complete
company-global-modes '(not term-mode)
company-backends (delete 'company-semantic
company-backends))
(setq company-backends '(company-capf
company-keywords
company-semantic
company-files
company-etags
company-elisp
company-clang
company-ispell
company-yasnippet))
(define-key company-mode-map
[remap indent-for-tab-command] 'company-indent-or-complete-common)
(defkeys company-active-map
"C-n" company-select-next
"C-p" company-select-previous))[x] company-c-headers
(with-hook company-c-headers-mode
(diminish 'company-c-headers-mode)
(add-to-list 'company-backends 'company-c-headers))[x] company-flx
(with-hook company
(company-flx-mode +1))[x] company-math
(with-package company-math
(diminish 'company-math-mode)
(add-to-list 'company-backends 'company-math-symbols-latex)
(add-to-list 'company-backends 'company-math-symbols-unicode))[x] company-quickhelp
(with-package company-quickhelp-mode
(diminish 'company-quickhelp-mode)
(add-hook 'global-company-mode-hook 'company-quickhelp-mode))[x] company-statistics
[x] company-try-hard
[x] company-web
[x] crux
[x] dap-mode
(with-package dap-mode
(dap-auto-configure-mode))[x] dash
[x] debbugs
[x] deferred
[x] deft
[x] diminish
[x] dired-hacks-utils
[x] dired-narrow
[x] dired-quick-sort
[x] dired-rsync
(with-hook after-init (when-idle (require 'dired-async)))
(with-package dired (require 'dired-async))[x] dired-subtree
(with-hook after-init (when-idle (require 'dired-subtree)))
(with-package dired-subtree
(setq dired-subtree-line-prefix " "
dired-subtree-use-backgrounds nil))[x] dumb-jump
[x] ecukes
[x] eldev
[x] elisp-def
[x] elisp-slime-nav
[x] elnode
[x] elpy
(with-package elpy
(elpy-enable)
(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
(defkeys elpy-mode-map
"C-M-n" elpy-nav-forward-block
"C-M-p" elpy-nav-backward-block))
(with-hook elpy-mode
;;(company-mode 1)
(flycheck-mode 1)
;;(make-local-variable 'company-backends)
;;(setq company-backends '((elpy-company-backend :with company-yasnippet)))
)[x] el-search
[x] emms
(with-hook after-init
(when-idle (require 'emms))
(defkeys global-map
;; emms
"C-v e SPC" emms-pause
"C-v e d" emms-play-directory
"C-v e l" emms-play-list
"C-v e n" emms-next
"C-v e p" emms-previous
"C-v e a" emms-add-directory
"C-v e A" emms-add-directory-tree
"C-v e +" pulseaudio-control-increase-volume
"C-v e -" pulseaudio-control-decrease-volume
"C-v e r" emms-start
"C-v e s" emms-stop
"C-v e m" emms-play-m3u-playlist))
(with-package emms
(require 'emms)
(require 'emms-setup)
(require 'emms-volume)
(require 'emms-source-file)
(require 'emms-source-playlist)
(require 'emms-playlist-mode)
(require 'emms-playlist-limit)
(require 'emms-playing-time)
(require 'emms-mode-line-cycle)
(require 'emms-player-mpv)
(emms-all)
(emms-history-load)
(emms-default-players)
(helm-mode 1)
;;(emms-mode-line 1)
;;(emms-playing-time-mode 1)
(setq-default emms-player-list '(emms-player-mpv)
emms-player-mpv-environment '("PULSE_PROP_media.role=music"))
;;emms-player-mpv-ipc-method nil)
;; emms-player-mpv-debug t
;; emms-player-mpv-environment '("PULSE_PROP_media.role=music")
;; emms-player-mpv-parameters '("--quiet" "--really-quiet" "--no-audio-display" "--force-window=no" "--vo=null"))
(setq emms-source-file-default-directory (expand-file-name "~/Musik"))
(setq emms-directory (expand-file-name "etc/emms/" user-emacs-directory)
emms-cache-file (expand-file-name "cache" emms-directory)
emms-history-file (expand-file-name "history" emms-directory)
emms-score-file (expand-file-name "scores" emms-directory)
emms-stream-bookmark-file (expand-file-name "streams" emms-directory)
emms-playlist-buffer-name "*Music Playlist*"
emms-show-format "Playing: %s"
;; Icon setup.
emms-mode-line-icon-before-format "["
emms-mode-line-format " %s]"
emms-playing-time-display-format "%s ]"
emms-mode-line-icon-color "lightgrey"
global-mode-string '("" emms-mode-line-string " " emms-playing-time-string)
emms-source-file-directory-tree-function 'emms-source-file-directory-tree-find
emms-browser-covers 'emms-browser-cache-thumbnail)
(add-to-list 'emms-info-functions 'emms-info-cueinfo)
(when (executable-find "emms-print-metadata")
(require 'emms-info-libtag)
(add-to-list 'emms-info-functions 'emms-info-libtag)
(delete 'emms-info-ogginfo emms-info-functions)
(delete 'emms-info-mp3info emms-info-functions)
(add-to-list 'emms-info-functions 'emms-info-ogginfo)
(add-to-list 'emms-info-functions 'emms-info-mp3info))
(add-hook 'emms-browser-tracks-added-hook 'z-emms-play-on-add)
(add-hook 'emms-player-started-hook 'emms-show))[x] emms-mode-line-cycle
[x] emr
[x] equake
(with-package equake
(advice-add #'save-buffers-kill-terminal :before-while #'equake-kill-emacs-advice)
(global-set-key (kbd "C-M-^") #'equake-restore-last-etab)
(setq equake-default-shell 'eshell)
;; set list of available shells
(setq equake-available-shells
'("shell"
"eshell"
"ielm")))[x] eros
[x] ert-runner
[x] espuds
[x] esup
[x] esxml
[x] evil
[x] evil-exchange
[x] evil-matchit
[x] evil-multiedit
[x] evil-snipe
[x] ewmctrl
[x] expand-region
(with-hook after-init
(defkeys global-map
"C-+" er/expand-region
"C--" er/contract-region))
(with-hook expand-region-mode
(diminish 'expand-region-mode))[x] f
[x] feebleline
[x] flimenu
(with-package flimenu
(flimenu-global-mode))[x] flycheck
[x] flycheck-package
[x] gh
[x] gist
[x] git-gutter
[x] github-search
[x] git-link
[x] git-messenger
[x] gnu-elpa-keyring-update
[x] google-c-style
(with-hook google-c-style-mode
(diminish 'google-c-style-mode))[x] goto-last-change
[x] helm
(with-hook after-init (when-idle
(require 'helm)
(require 'helm-config)
(require 'helm-eshell)
(require 'helm-buffers)
(require 'helm-files)
(message "Helm loaded on idle.")))
(with-hook eshell-mode
(defkeys eshell-mode-map
"C-c C-h" helm-eshell-history
"C-c C-r" helm-comint-input-ring
"C-c C-l" helm-minibuffer-history))
(with-hook helm-ff-cache-mode
(diminish 'helm-ff-cache-mode))
(with-package helm
(require 'helm-config)
(require 'helm-eshell)
(require 'helm-buffers)
(require 'helm-files)
(defvar helm-source-header-default-background (face-attribute
'helm-source-header :background))
(defvar helm-source-header-default-foreground (face-attribute
'helm-source-header :foreground))
(defvar helm-source-header-default-box (face-attribute
'helm-source-header :box))
(set-face-attribute 'helm-source-header nil :height 0.1)
(defun helm-toggle-header-line ()
(if (gt (length helm-sources) 1)
(set-face-attribute 'helm-source-header
nil
:foreground helm-source-header-default-foreground
:background helm-source-header-default-background
:box helm-source-header-default-box
:height 1.0)
(set-face-attribute 'helm-source-header
nil
:foreground (face-attribute 'helm-selection :background)
:background (face-attribute 'helm-selection :background)
:box nil
:height 0.1)))
;; https://xenodium.com/change-emacs-shells-cwd-with-helm-projectile/
(require 'helm-projectile)
(defun shell-cd (dir-path)
"Like shell-pop--cd-to-cwd-shell, but without recentering."
(unless (string-equal mode-name "Shell")
(error "Not in Shell mode"))
(message mode-name)
(goto-char (point-max))
(comint-kill-input)
(insert (concat "cd " (shell-quote-argument dir-path)))
(let ((comint-process-echoes t))
(comint-send-input)))
;; (defun helm-projectile-shell-cd ()
;; "Change shell current working directory using helm projectile."
;; (interactive)
;; (unless (string-equal mode-name "Shell")
;; (error "Not in Shell mode"))
;; (let ((helm-dir-source (copy-tree helm-source-projectile-directories-list)))
;; (add-to-list '(action . shell-cd) helm-dir-source)
;; (add-to-list '(keymap . nil) helm-dir-source)
;; (add-to-list '(header-line . "cd to directory...") helm-dir-source)
;; (helm :sources helm-dir-source
;; :buffer "*helm-dirs*"
;; :candidate-number-limit 10000)))
(defun my-helm-next-source ()
(interactive)
(helm-next-source)
(helm-next-line))
;; (defun my-helm-return ()
;; (interactive)
;; (helm-select-nth-action 0))
(setq helm-completion-style 'emacs
helm-display-header-line nil
helm-completion-in-region-fuzzy-match t
helm-recentf-fuzzy-match t
helm-buffers-fuzzy-matching t
helm-locate-fuzzy-match t
helm-lisp-fuzzy-completion t
helm-session-fuzzy-match t
helm-apropos-fuzzy-match t
helm-imenu-fuzzy-match t
helm-semantic-fuzzy-match t
helm-M-x-fuzzy-match t
helm-split-window-inside-p t
helm-move-to-line-cycle-in-source t
helm-ff-search-library-in-sexp t
helm-scroll-amount 8
helm-ff-file-name-history-use-recentf t
helm-ff-auto-update-initial-value t
helm-net-prefer-curl t
helm-autoresize-max-height 0
helm-autoresize-min-height 30
helm-candidate-number-limit 100
helm-idle-delay 0.0
helm-input-idle-delay 0.0
helm-ff-cache-mode-lighter-sleep nil
helm-ff-cache-mode-lighter-updating nil
helm-ff-cache-mode-lighter nil
helm-ff-skip-boring-files t)
(dolist (regexp '("\\`\\*direnv" "\\`\\*straight" "\\`\\*xref"))
(push regexp helm-boring-buffer-regexp-list))
(helm-autoresize-mode 1)
(helm-adaptive-mode t)
(helm-mode 1)
(add-to-list 'helm-sources-using-default-as-input
'helm-source-man-pages)
(setq helm-mini-default-sources '(helm-source-buffers-list
helm-source-bookmarks
helm-source-recentf
helm-source-buffer-not-found
projectile-known-projects))
(defkeys helm-map
"M-i" helm-previous-line
"M-k" helm-next-line
"M-I" helm-previous-page
"M-K" helm-next-page
"M-h" helm-beginning-of-buffer
"M-H" helm-end-of-buffer)
(defkeys helm-read-file-map
"C-o" my-helm-next-source
;;"RET" my-helm-return
))
(with-hook after-init
(defkeys global-map
"M-x" helm-M-x
"C-z ," helm-pages
"C-x C-b" helm-buffers-list
"C-z a" helm-ag
"C-z b" helm-filtered-bookmarks
"C-z c" helm-company
"C-z d" helm-dabbrev
"C-z e" helm-calcul-expression
"C-z g" helm-google-suggest
"C-z h" helm-descbinds
"C-z i" helm-imenu-anywhere
"C-z k" helm-show-kill-ring
"C-z C-c" helm-git-local-branches
"C-z f" helm-find-files
"C-z m" helm-mini
"C-z o" helm-occur
"C-z p" helm-browse-project
"C-z q" helm-apropos
"C-z r" helm-recentf
"C-z s" helm-swoop
"C-z C-c" helm-colors
"C-z x" helm-M-x
"C-z y" helm-yas-complete
"C-z C-g" helm-ls-git-ls
"C-z C-b" helm-git-local-branches
"C-z SPC" helm-all-mark-rings))[x] helm-ag
(with-package helm-ag
(setq helm-ag-use-agignore t
helm-ag-base-command
"ag --mmap --nocolor --nogroup --ignore-case --ignore=*terraform.tfstate.backup*"))[x] helm-company
[x] helm-c-yasnippet
(with-package helm-c-yasnippet
(setq helm-yas-space-match-any-greedy t))[x] helm-dash
[x] helm-descbinds
[x] helm-dired-history
(with-package helm-dired-history
(require 'savehist)
(add-to-list 'savehist-additional-variables
'helm-dired-history-variable)
(savehist-mode 1)
(with-eval-after-load "dired"
(require 'helm-dired-history)
(define-key dired-mode-map "," 'dired)))[x] helm-emms
[x] helm-firefox
[x] helm-flx
(with-package helm
(when-idle
(setq helm-flx-for-helm-find-files t
helm-flx-for-helm-locate t)
(helm-flx-mode +1)))[x] helm-flyspell
[x] helm-fuzzier
[x] helm-git-grep
[x] helm-ls-git
[x] helm-lsp
(with-package helm-lsp
(defun netrom/helm-lsp-workspace-symbol-at-point ()
(interactive)
(let ((current-prefix-arg t))
(call-interactively 'helm-lsp-workspace-symbol)))
(defun netrom/helm-lsp-global-workspace-symbol-at-point ()
(interactive)
(let ((current-prefix-arg t))
(call-interactively 'helm-lsp-global-workspace-symbol)))
(setq netrom--general-lsp-hydra-heads
'(;; Xref
("d" xref-find-definitions "Definitions" :column "Xref")
("D" xref-find-definitions-other-window "-> other win")
("r" xref-find-references "References")
("s" netrom/helm-lsp-workspace-symbol-at-point "Helm search")
("S" netrom/helm-lsp-global-workspace-symbol-at-point "Helm global search")
;; Peek
("C-d" lsp-ui-peek-find-definitions "Definitions" :column "Peek")
("C-r" lsp-ui-peek-find-references "References")
("C-i" lsp-ui-peek-find-implementation "Implementation")
;; LSP
("p" lsp-describe-thing-at-point "Describe at point" :column "LSP")
("C-a" lsp-execute-code-action "Execute code action")
("R" lsp-rename "Rename")
("t" lsp-goto-type-definition "Type definition")
("i" lsp-goto-implementation "Implementation")
("f" helm-imenu "Filter funcs/classes (Helm)")
("C-c" lsp-describe-session "Describe session")
;; Flycheck
("l" lsp-ui-flycheck-list "List errs/warns/notes" :column "Flycheck"))
netrom--misc-lsp-hydra-heads
'(;; Misc
("q" nil "Cancel" :column "Misc")
("b" pop-tag-mark "Back")))
;; Create general hydra.
(eval `(defhydra netrom/lsp-hydra (:color blue :hint nil)
,@(append
netrom--general-lsp-hydra-heads
netrom--misc-lsp-hydra-heads)))
(defkeys lsp-mode-map
[remap xref-find-apropos] helm-lsp-workspace-symbol
"C-c C-l" netrom/lsp-hydra/body))[x] helm-make
[x] helm-navi
[x] helm-org
[x] helm-pages
[x] helm-projectile
[x] helm-sly
[x] helm-smex
[x] helm-swoop
[x] helm-system-packages
[x] helm-xref
[x] helpful
(with-package helpful
(define-key helpful-mode-map (kbd "i")
(lambda nil (interactive) (info-lookup 'symbol helpful--sym #'emacs-lisp-mode)))
(setq helpful-max-buffers 1))
(with-hook after-init
(defkeys global-map
"C-h C-v" helpful-variable
"C-h C-k" helpful-key
"C-h C-f" helpful-callable
"C-h C-j" helpful-at-point
"C-h C-u" helpful-command))[x] hide-mode-line
[x] ht
[x] hydra
(with-package hydra
(defkeys global-map
"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"))
"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)(goto-char (point-max)) "end"))
("c" recenter-top-bottom "recenter")
("n" next-line "down")
("p" (lambda () (interactive) (forward-line -1)) "up")
("g" goto-line "goto-line"))
"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") ; Dont forget to define the captures you want http://orgmode.org/manual/Capture.html
("l" (or )rg-capture-goto-last-stored "Last Capture"))))[x] iedit
[x] imenu-anywhere
[x] import-js
[x] kv
[x] lispy
[x] lsp-java
[x] lsp-mode
(with-package lsp-mode
(setq lsp-diagnostic-provider :none
lsp-keymap-prefix "C-f"
lsp-completion-provider t
lsp-enable-xref t
lsp-auto-configure t
lsp-auto-guess-root t
;;lsp-inhibit-message t
lsp-enable-snippet t
lsp-restart 'interactive
lsp-log-io nil
lsp-idle-delay 0.1
lsp-enable-links nil
lsp-enable-symbol-highlighting nil
lsp-keep-workspace-alive t
lsp-clients-clangd-args '("-j=4" "-background-index" "-log=error")
;; python
;; lsp-python-executable-cmd "python3"
;; lsp-python-ms-executable "~/repos/python-language-server/output/bin/Release/osx-x64/publish/Microsoft.Python.LanguageServer"
lsp-enable-completion-enable t)
(add-hook 'lsp-mode-hook #'lsp-enable-which-key-integration)
(add-hook 'lsp-managed-mode-hook (lambda () (setq-local company-backends
'(company-capf))))
(require 'dap-cpptools)
(diminish 'lsp-mode))
(with-hook python-mode
(lsp-deferred))[x] lsp-pyright
(with-package lsp-pyright
(setq lsp-clients-python-library-directories '("/usr"
"~/miniconda3/pkgs")
lsp-pyright-disable-language-service nil
lsp-pyright-dsable-organize-imports nil
lsp-pyright-auto-import-completions t
lsp-pyright-use-library-code-for-types t
lsp-pyright-venv-pat "~/miniconda3/envs"))
(with-hook python-mode
(require 'lsp-pyright)
(lsp-deferred)
(setq python-shell-interpreter "ipython"
python-shell-interpreter-args "-i --simple-prompt"))[x] lsp-treemacs
[x] lsp-ui
(with-package lsp-ui
(add-hook 'lsp-mode-hook 'lsp-ui-mode)
(setq lsp-ui-doc-enable t
lsp-ui-doc-header t
lsp-ui-doc-delay 2
lsp-ui-doc-include-signature t
lsp-ui-doc-position 'top
lsp-ui-doc-border (face-foreground 'default)
lsp-ui-sideline-enable nil
lsp-ui-sideline-ignore-duplicate t
lsp-ui-sideline-show-code-actions nil
lsp-ui-sideline-ignore-duplicate t
;; Use lsp-ui-doc-webkit only in GUI
lsp-ui-doc-use-webkit t
;; WORKAROUND Hide mode-line of the lsp-ui-imenu buffer
;; https://github.com/emacs-lsp/lsp-ui/issues/243
;;mode-line-format nil
)
(defadvice lsp-ui-imenu (after hide-lsp-ui-imenu-mode-line activate))
(defkeys lsp-ui-mode-map
[remap xref-find-references] lsp-ui-peek-find-references
[remap xref-find-definitions] lsp-ui-peek-find-definitions
"C-c u" lsp-ui-imenu))
(with-hook lsp-ui-mode
(diminish 'lsp-ui-mode))[x] lusty-explorer
[x] macro-math
[x] magit
[x] magit-filenotify
[x] markdown-mode
[x] marshal
[x] mc-extras
[x] mmm-mode
[x] modern-cpp-font-lock
(with-hook modern-cpp-font-lock-mode
(diminish 'modern-cpp-font-lock-mode))[x] multiple-cursors
[x] nadvice
[x] navi-mode
[x] nov
(with-hook after-init
(add-to-list 'auto-mode-alist '("\\.epub\\'" . nov-mode)))[x] oauth2 :disable
[x] org
(with-hook org-mode
(when (equal (buffer-name) "init.org")
(org-babel-hide-markers-mode 1)
(page-break-lines-mode 1)
(org-pretty-table-mode 1)))
(with-package org
(require 'org-protocol)
(defun get-html-title-from-url (url)
"Return content in <title> tag."
(require 'mm-url)
(let (x1 x2 (download-buffer (url-retrieve-synchronously url)))
(with-current-buffer download-buffer
(goto-char (point-min))
(setq x1 (search-forward "<title>"))
(search-forward "</title>")
(setq x2 (search-backward "<"))
(mm-url-decode-entities-string (buffer-substring-no-properties x1 x2)))))
(defun my-org-insert-link ()
"Insert org link where default description is set to html title."
(interactive)
(let* ((url (read-string "URL: "))
(title (get-html-title-from-url url)))
(org-insert-link nil url title)))
(defun org-agenda-show-agenda-and-todo (&optional arg)
""
(interactive "P")
(org-agenda arg "c")
(org-agenda-fortnight-view))
;; ("P" "Research project" entry (file "~/Org/inbox.org")
;; "* TODO %^{Project title} :%^G:\n:PROPERTIES:\n:CREATED:
;; %U\n:END:\n%^{Project description}\n** [x]
;; TODO Literature review\n** [x] TODO %?\n** [x]
;; TODO Summary\n** [x] TODO Reports\n** [x] Ideas\n"
;; :clock-in t :clock-resume t)
(defun transform-square-brackets-to-round-ones(string-to-transform)
"Transforms [ into ( and ] into ), other chars left unchanged."
(concat
(mapcar #'(lambda (c)
(if (equal c ?[) ?\( (if (equal c ?]) ?\) c ))) string-to-transform)))
(setq org-capture-templates
`(("p" "Protocol" entry (file+headline "~/Dokument/notes.org" "Inbox")
"* %^{Title}\nSource: %u, %c\n #+BEGIN_QUOTE\n%i\n#+END_QUOTE\n\n\n%?")
("L" "Protocol Link" entry (file+headline "~/Dokument/notes.org" "Inbox")
"* %? [[%:link][%(transform-square-brackets-to-round-ones\"%:description\")]]\n")
("n" "Note" entry (file "~/Dokument/notes.org")
"* %? %^G\n%U" :empty-lines 1)
("e" "Email" entry (file "~/Org/inbox.org")
"* TODO %? email |- %:from: %:subject :EMAIL:\n:PROPERTIES:\n:CREATED: %U\n:EMAIL-SOURCE: %l\n:END:\n%U\n" :clock-in t :clock-resume t)))
(setq org-log-done 'time
org-ditaa-jar-path "/usr/bin/ditaa"
org-todo-keywords '((sequence "TODO" "INPROGRESS" "DONE"))
org-todo-keyword-faces '(("INPROGRESS" . (:foreground "blue" :weight bold)))
org-directory (expand-file-name "~/Dokument/")
org-default-notes-file (expand-file-name "notes.org" org-directory)
org-use-speed-commands t
org-src-preserve-indentation t
org-export-html-postamble nil
org-hide-leading-stars t
org-make-link-description t
org-hide-emphasis-markers t
org-startup-folded 'overview
org-startup-indented nil))[x] org-appear
[x] org-download
[x] org-noter-pdftools
(unless (equal system-type 'windows-nt)
(with-package pdf-annot
(add-hook 'pdf-annot-activate-handler-functions #'org-noter-pdftools-jump-to-note)))[x] org-pdftools
(unless (eq system-type 'windows-nt)
(with-hook org-load
(org-pdftools-setup-link)))[x] org-projectile
(with-package org-projectile
(require 'org-projectile)
(setq org-projectile-projects-file "~Dokument/todos.org"
org-agenda-files (append org-agenda-files (org-projectile-todo-files)))
(push (org-projectile-project-todo-entry) org-capture-templates)
(defkeys global-map
"C-c n p" org-projectile-project-todo-completing-read
"C-c c" org-capture))[x] org-projectile-helm
[x] org-sidebar
[x] org-superstar
[x] overseer
[x] package-lint
[x] package-lint
[x] page-break-lines
[x] pdf-tools
(unless (equal system-type 'windows-nt)
(with-package pdf-tools
;;(pdf-tools-install)
(setq-default pdf-view-display-size 'fit-page)))[x] peep-dired
[x] pfuture
[x] plisp-mode
[x] polymode
[x] prettier-js
(with-package prettier-js
(diminish 'prettier-js-mode))
(with-hook js2-mode
(prettier-js-mode))
(with-hook rjsx-mode
(prettier-js-mode))[x] pretty-symbols
[x] prodigy
[x] projectile
(with-package projectile
(setq projectile-indexing-method 'alien))[x] pulseaudio-control
[x] pyenv-mode
(with-package pyenv-mode
(setq python-shell-interpreter "ipython"
python-shell-interpreter-args "-i --simple-prompt"))[x] pyvenv
(with-package pyvenv
(setenv "WORKON_HOME" (expand-file-name "~/miniconda3/envs"))
(setq pyvenv-menu t))
(with-hook pyvenv-post-activate-hooks
(pyvenv-restart-python))
(with-hook python-mode
(pyvenv-mode +1)) [x] qrencode
[x] recentf
[x] refine
[x] request
[x] rjsx-mode
(with-package rjsx-mode
(setq js2-mode-show-parse-errors nil
js2-mode-show-strict-warnings nil
js2-basic-offset 2
js-indent-level 2)
(setq-local flycheck-disabled-checkers (cl-union flycheck-disabled-checkers
'(javascript-jshint))) ; jshint doesn't work for JSX
(electric-pair-mode 1))
(with-hook after-init
(add-to-list 'auto-mode-alist '("\\.js\\'" . rjsx-mode))
(add-to-list 'auto-mode-alist '("\\.jsx\\'" . rjsx-mode)))[x] run-command
[x] s
[x] sly
(with-package sly
(setq inferior-lisp-program "/usr/bin/sbcl")
(defkeys sly-prefix-map
"M-h" sly-documentation-lookup))[x] sly-macrostep
[x] sly-named-readtables
[x] smart-jump
[x] smex
[x] smooth-scrolling
[x] solarized-theme
(with-hook after-init
(load-theme 'solarized-dark t))[x] sphinx-doc
[x] string-edit
[x] system-packages
[x] tide
[x] treemacs
(with-package treemacs
(setq treemacs-no-png-images t
treemacs-width 24))
(with-hook python-mode
(defkeys python-mode-map
"C-f t" treemacs))[x] which-key
(with-hook after-init
(which-key-mode t)
(diminish 'which-key-mode))[x] winum
[x] with-simulated-input
[x] wrap-region
(with-hook after-init
(wrap-region-global-mode t)
(diminish 'wrap-region-mode))[x] yapfify
(with-hook python-mode
(yapf-mode +1))[x] yasnippet
(when-idle (require 'yasnippet))
(with-package yasnippet
(add-hook 'hippie-expand-try-functions-list 'yas-hippie-try-expand)
(setq yas-key-syntaxes '("w_" "w_." "^ ")
;; yas-snippet-dirs (eval-when-compile
;; (list (expand-file-name "~/.emacs.d/snippets")))
yas-expand-only-for-last-commands nil)
(define-key yas-minor-mode-map (kbd "C-i") nil)
(define-key yas-minor-mode-map (kbd "TAB") nil)
(define-key yas-minor-mode-map (kbd "<tab>") nil)
(define-key yas-minor-mode-map (kbd "C-<return>") 'yas-expand))
(with-hook yas-minor-mode
(diminish 'yas-mode 'yas-minor-mode))[x] yasnippet-snippets
[ melpa ] [x] academic-phrases
[ none ] [x] c/c++
(with-hook after-init
(add-hook 'c-initialization-hook 'my-c-init)
(add-hook 'c++-mode-hook 'my-c++-init)
(add-to-list 'auto-mode-alist '("\\.\\(c\\|h\\|inc\\|src\\)\\'" . c-mode))
(add-to-list 'auto-mode-alist '("\\.\\(|hh\\|cc\\|c++\\|cpp\\|tpp\\|hpp\\|hxx\\|cxx\\|inl\\|cu\\)'" . c++-mode))
(when-idle (require 'c++-setup)))[ none ] [x] dap-java
[ none ] [x] dired
(with-hook after-init
(defkeys global-map
"C-x C-j" dired-jump
"C-x 4 C-j" dired-jump-other-window)
(when-idle (require 'dired-extras)))
(with-package dired
(require 'dired-extras)
(setq dired-dwim-target t
global-auto-revert-non-file-buffers nil
dired-recursive-copies 'always
dired-recursive-deletes 'always
dired-listing-switches "-lA --si --time-style=long-iso --group-directories-first"
wdired-use-vertical-movement t
wdired-allow-to-change-permissions t
dired-omit-files-p t
dired-omit-files (concat dired-omit-files "\\|^\\..+$"))
(setq openwith-associations
(list (list (openwith-make-extension-regexp
'("flac" "mpg" "mpeg" "mp3" "mp4"
"avi" "wmv" "wav" "mov" "flv"
"ogm" "ogg" "mkv" "webm"))
"mpv"
'(file))
(list (openwith-make-extension-regexp
'("html" "htm"))
(getenv "BROWSER")
'(file))))
(with-system windows-nt
(setq ls-lisp-use-insert-directory-program "gls"))
(with-system gnu/linux
(dolist (ext (list (list (openwith-make-extension-regexp
'("xbm" "pbm" "pgm" "ppm" "pnm"
"png" "gif" "bmp" "tif" "jpeg" "jpg"))
"feh"
'(file))
(list (openwith-make-extension-regexp
'("doc" "xls" "ppt" "odt" "ods" "odg" "odp" "rtf"))
"libreoffice"
'(file))
(list (openwith-make-extension-regexp
'("\\.lyx"))
"lyx"
'(file))
(list (openwith-make-extension-regexp
'("chm"))
"kchmviewer"
'(file))
(list (openwith-make-extension-regexp
'("pdf" "ps" "ps.gz" "dvi" "epub" "djv" "djvu" "mobi"))
"okular"
'(file))))
(add-to-list 'openwith-associations ext)))
(defkeys dired-mode-map
"C-x <M-S-return>" dired-open-current-as-sudo
"r" dired-do-rename
"C-S-r" wdired-change-to-wdired-mode
;; "C-r C-s" tmtxt/dired-async-get-files-size
;; "C-r C-r" tda/rsync
;; "C-r C-z" tda/zip
;; "C-r C-u" tda/unzip
;; "C-r C-a" tda/rsync-multiple-mark-file
;; "C-r C-e" tda/rsync-multiple-empty-list
;; "C-r C-d" tda/rsync-multiple-remove-item
;; "C-r C-v" tda/rsync-multiple
;; "C-r C-s" tda/get-files-size
;; "C-r C-q" tda/download-to-current-dir
"S-<return>" dired-openwith
"C-'" dired-collapse-mode
"M-p" scroll-down-line
"M-m" dired-mark-backward
"M-<" dired-goto-first
"M->" dired-goto-last
"M-<return>" my-run
"C-S-f" dired-narrow
"P" peep-dired
"<f1>" term-toggle
"TAB" dired-subtree-toggle
"f" dired-subtree-fold-all
"z" dired-get-size
"e" dired-subtree-expand-all)
)
(with-hook dired-mode
(dired-omit-mode t)
(dired-async-mode t)
(dired-hide-details-mode)
(dired-auto-readme-mode t))[ none ] [x] early-init
(with-hook early-init
(defvar default-gc-cons-threshold gc-cons-threshold)
(defvar old-file-name-handler file-name-handler-alist)
(setq file-name-handler-alist nil
gc-cons-threshold most-positive-fixnum
frame-inhibit-implied-resize t
bidi-inhibit-bpa t
initial-scratch-message ""
inhibit-splash-screen t
inhibit-startup-screen t
inhibit-startup-message t
inhibit-startup-echo-area-message t
show-paren-delay 0
use-dialog-box nil
visible-bell nil
ring-bell-function 'ignore
load-prefer-newer t
shell-command-default-error-buffer "Shell Command Errors"
native-comp-async-report-warnings-errors 'silent
comp-speed 3)
(when 'native-comp-compiler-options
(setq native-comp-compiler-options '("-O2" "-march=skylake" "-mtune=native")))
(setq-default abbrev-mode t
indent-tabs-mode nil
indicate-empty-lines t
cursor-type 'bar
fill-column 80
auto-fill-function 'do-auto-fill
cursor-in-non-selected-windows 'hollow
bidi-display-reordering 'left-to-right
bidi-paragraph-direction 'left-to-right)
(push '(menu-bar-lines . 0) default-frame-alist)
(push '(tool-bar-lines . 0) default-frame-alist)
(push '(vertical-scroll-bars . nil) default-frame-alist)
(push '(font . "Anonymous Pro-16") default-frame-alist)
;; (push '(font . "Some imaginary font") default-frame-alist)
;;(custom-set-faces '(default ((t (:height 120)))))
;; (let ((default-directory (expand-file-name "lisp" user-emacs-directory)))
;; (normal-top-level-add-to-load-path '("."))
;; (normal-top-level-add-subdirs-to-load-path))
;; (let ((deff (gethash 'default face--new-frame-defaults)))
;; (aset (cdr deff) 4 240)
;; (puthash 'default deff face--new-frame-defaults))
(define-prefix-command 'C-z-map)
(global-set-key (kbd "C-z") 'C-z-map)
(global-unset-key (kbd "C-v")))[ none ] [x] emacs
(with-hook after-init
(setenv "BROWSER" "firefox-developer-edition")
(with-system windows-nt
;; (global-disable-mouse-mode 1)
(setq w32-get-true-file-attributes nil
w32-pipe-read-delay 0
w32-pipe-buffer-size (* 64 1024)
;;package-gnupghome-dir "c:/Users/arthu/.emacs.d/elpa/gnupg"
source-directory "c:/emacs/emsrc/emacs"
command-line-x-option-alist nil
command-line-ns-option-alist nil))
(let ((etc (expand-file-name "etc" user-emacs-directory)))
(unless (file-directory-p etc)
(make-directory etc))
(setq show-paren-style 'expression
shell-file-name "bash"
shell-command-switch "-ic"
delete-exited-processes t
echo-keystrokes 0.1
winner-dont-bind-my-keys t
auto-window-vscroll nil
require-final-newline t
next-line-add-newlines t
bookmark-save-flag 1
delete-selection-mode t
initial-major-mode 'emacs-lisp-mode
confirm-kill-processes nil
help-enable-symbol-autoload t
large-file-warning-threshold nil
save-abbrevs 'silent
save-interprogram-paste-before-kill t
save-place-file (expand-file-name "places" etc)
max-lisp-eval-depth '100000
max-specpdl-size '1000000
scroll-preserve-screen-position 'always
scroll-conservatively 1
maximum-scroll-margin 1
scroll-margin 0
make-backup-files nil
kill-buffer-delete-auto-save-files t
backup-directory-alist `(("." . ,etc))
custom-file (expand-file-name "custom.el" etc)
abbrev-file-name (expand-file-name "abbrevs.el" etc)
bookmark-default-file (expand-file-name "bookmarks" etc)))
(add-to-list 'display-buffer-alist '("\\*Compile-Log\\*"
(display-buffer-no-window)))
(add-to-list 'display-buffer-alist
`((,(rx bos (or "*Apropos*" "*Help*" "*helpful*" "*info*" "*Summary*")
(0+ not-newline))
(display-buffer-same-window)
(dedicated t)
(display-buffer-reuse-mode-window display-buffer-pop-up-window)
(mode apropos-mode help-mode helpful-mode Info-mode Man-mode))))
(add-to-list 'display-buffer-alist '(("*Help*" (window-parameters . ((dedicated . t))))))
(fset 'yes-or-no-p 'y-or-n-p)
(electric-indent-mode 1)
(electric-pair-mode 1)
(global-auto-revert-mode)
(global-hl-line-mode 1)
(global-subword-mode 1)
(auto-compression-mode 1)
(auto-image-file-mode)
(auto-insert-mode 1)
(auto-save-mode 1)
(blink-cursor-mode 1)
(column-number-mode 1)
(delete-selection-mode 1)
(display-time-mode 1)
(pending-delete-mode 1)
(show-paren-mode t)
(save-place-mode 1)
(winner-mode t)
(turn-on-auto-fill)
(diminish 'winner-mode)
(diminish 'eldoc-mode)
(diminish 'electric-pair-mode)
(diminish 'auto-complete-mode)
(diminish 'abbrev-mode)
(diminish 'auto-fill-function)
(diminish 'subword-mode)
(diminish 'auto-insert-mode)
(defkeys global-map
;; Window-buffer operations
"C-<insert>" term-toggle-term
"<insert>" term-toggle-eshell
"C-v C-t" term-toggle-ielm
[f9] ispell-word
[S-f10] next-buffer
[f10] previous-buffer
[f12] kill-buffer-but-not-some
[M-f12] kill-buffer-other-window
[C-M-f12] only-current-buffer
;; Emacs windows
"C-v <left>" windmove-swap-states-left
"C-v <right>" windmove-swap-states-right
"C-v <up>" windmove-swap-states-up
"C-v <down>" windmove-swap-states-down
"C-v o" other-window
"C-v j" windmove-left
"C-v l" windmove-right
"C-v i" windmove-up
"C-v k" windmove-down
;; "C-v a" send-to-window-left
;; "C-v d" send-to-window-right
;; "C-v w" send-to-window-up
;; "C-v s" send-to-window-down
;; "C-v v" maximize-window-vertically
;; "C-v h" maximize-window-horizontally
"C-v n" next-buffer
"C-v p" previous-buffer
"C-v C-+" enlarge-window-horizontally
"C-v C-," enlarge-window-vertically
"C-v C--" shrink-window-horizontally
"C-v C-." shrink-window-vertically
"C-v u" winner-undo
"C-v r" winner-redo
"C-v C-k" delete-window
"C-v C-l" windmove-delete-left
"C-v C-r" windmove-delete-right
"C-v C-a" windmove-delete-up
"C-v C-b" windmove-delete-down
"C-v <return>" delete-other-windows
"C-v ," split-window-right
"C-v ." split-window-below
"C-h M-i" help-toggle-source-view
;; "C-v C-s" swap-two-buffers
[remap other-window] ace-window
;; cursor movement
"M-n" scroll-up-line
"M-N" scroll-up-command
"M-p" scroll-down-line
"M-P" scroll-down-command
"C-v c" org-capture
"C-v C-c" avy-goto-char
"C-v C-v" avy-goto-word-1
"C-v C-w" avy-goto-word-0
"C-v C-g" avy-goto-line
;; some random stuff
"C-h C-i" (lambda()
(interactive)
(find-file (expand-file-name
"init.org"
user-emacs-directory))))
(when-idle (require 'extras))
(when-idle (require 'sv-kalender)
;;(add-to-list 'special-display-frame-alist '(tool-bar-lines . 0))
(when (and custom-file (file-exists-p custom-file))
(load custom-file 'noerror))
(add-hook 'comint-output-filter-functions
#'comint-watch-for-password-prompt)
(setq gc-cons-threshold default-gc-cons-threshold
gc-cons-percentage 0.1
file-name-handler-alist old-file-name-handler)))
(with-hook text-mode
(setq fill-column 240))[ none ] [x] emacs-director
[ none ] [x] emacs-gif-screencast
[ none ] [x] emacs-run-command
[ none ] [x] emacs-velocity
[ none ] [x] gnus
(with-hook after-init
(require 'gnus))
(with-hook message-mode
(setq fill-column 80))
(with-package gnus
;;(require 'nnir)
(setq user-full-name "Arthur Miller"
user-mail-address "arthur.miller@live.com")
;; for the outlook
(setq gnus-select-method '(nnimap "live.com"
(nnimap-address "imap-mail.outlook.com")
(nnimap-server-port 993)
(nnimap-stream ssl)
;;(nnir-search-engine imap)
))
(add-to-list 'gnus-secondary-select-methods '(nnhackernews ""))
;; Send email through SMTP
(setq message-send-mail-function 'smtpmail-send-it
smtpmail-default-smtp-server "smtp-mail.outlook.com"
smtpmail-smtp-service 587
smtpmail-local-domain "homepc")
(setq gnus-thread-sort-functions
'(gnus-thread-sort-by-most-recent-date
(not gnus-thread-sort-by-number)))
(setq gnus-use-cache t gnus-view-pseudo-asynchronously t)
;; Show more MIME-stuff:
(setq gnus-mime-display-multipart-related-as-mixed t)
;; http://www.gnu.org/software/emacs/manual/html_node/gnus/_005b9_002e2_005d.html
(setq gnus-use-correct-string-widths nil)
(setq nnmail-expiry-wait 'immediate)
;; Smileys:
(setq smiley-style 'medium)
;; Use topics per default:
(add-hook 'gnus-group-mode-hook 'gnus-topic-mode)
(setq gnus-message-archive-group '((format-time-string "sent.%Y")))
(setq gnus-server-alist '(("archive" nnfolder "archive" (nnfolder-directory "~/mail/archive")
(nnfolder-active-file "~/mail/archive/active")
(nnfolder-get-new-mail nil)
(nnfolder-inhibit-expiry t))))
(setq gnus-topic-topology '(;;("Gnus" visible)
;;(("misc" visible))
("live.com" visible)))
;; each topic corresponds to a public imap folder
(setq gnus-topic-alist '(("live.com")
("Gnus")))
)[ none ] [x] helm-convert
[ none ] [x] ielm
(with-hook ielm
(turn-on-eldoc-mode))[ none ] [x] inferior-python-mode
(with-hook inferior-python-mode
(hide-mode-line-mode))[ none ] [x] lisp & elisp
(with-hook after-init
(set-default 'auto-mode-alist
(append '(("\\.lisp" . lisp-mode)
("\\.lsp" . lisp-mode)
("\\.cl" . lisp-mode))
auto-mode-alist)))
(with-package elisp-mode
(require 'elisp-extras)
(require 'helm-pages)
;;(require 'helm-extras)
(defkeys emacs-lisp-mode-map
"\C-c a" emacs-lisp-byte-compile-and-load
"\C-c b" emacs-lisp-byte-compile
"\C-c c" emacs-lisp-native-compile-and-load
"\C-c d" eval-defun
"\C-c e" eval-buffer
"\C-c i" reindent-buffer
"\C-c l" eval-last-sexp
"\C-c n" eval-next-sexp
"\C-c r" fc-eval-and-replace
"\C-c s" eval-surrounding-sexp))
(with-hook emacs-lisp-mode
(setq fill-column 80)
(company-mode 1)
(outshine-mode 1)
(yas-minor-mode 1)
(page-break-lines-mode 1))[ none ] [x] speed-of-thought-lisp
[ none ] [x] system-cores.el
[ none ] [x] term-toggle
(with-package term-toggle
(setq term-toggle-no-confirm-exit t
term-toggle-kill-buffer-on-term-exit t))[ none ] [x] wdired
(with-package wdired
(defkeys wdired-mode-map
"<return>" dired-find-file
"M-<return>" my-run
"S-<return>" dired-openwith
"M-<" dired-go-to-first
"M->" dired-go-to-last
"M-p" scroll-down-line))