svragv/emaks
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
emaks/config.org

834 lines
27 KiB
Org Mode
Raw Blame History

#+TITLE: emacs config
* suragu's Emacs config
This is my Emacs configuration, if you don't like it, that's ok
because I made it thinking of myself. the code here is tidy
so anyone could modify it without great pain.
** Installation
Just copy this repository to your emacs configuration path. Nothing
else is needed.
* Why?
- I can
- I don't like doom emacs
- I don't like spacemacs
- I don't want to learn doom emacs
- I don't want to learn spacemacs
- I don't like Vim
* gc
#+begin_src emacs-lisp
;; Minimize garbage collection during startup
(setq gc-cons-threshold most-positive-fixnum)
;; Lower threshold back to 8 MiB (default is 800kB)
(add-hook 'emacs-startup-hook
(lambda ()
(setq gc-cons-threshold (expt 2 23))))
#+end_src
* melpa crap, and basic packages installation
melpa, where you get the packages. This also installs use-package,
and other packages I use.
#+BEGIN_SRC emacs-lisp
(require 'package)
(let* ((no-ssl (and (memq system-type '(windows-nt ms-dos))
(not (gnutls-available-p))))
(proto (if no-ssl "http" "https")))
;; Comment/uncomment these two lines to enable/disable MELPA and MELPA Stable as desired
(add-to-list 'package-archives (cons "melpa" (concat proto "://melpa.org/packages/")) t)
;;(add-to-list 'package-archives (cons "melpa-stable" (concat proto "://stable.melpa.org/packages/")) t)
(when (< emacs-major-version 24)
;; For important compatibility libraries like cl-lib
(add-to-list 'package-archives '("gnu" . (concat proto "://elpa.gnu.org/packages/")))))
(if (< emacs-major-version 27)
(package-initialize))
(unless (package-installed-p 'use-package)
(package-refresh-contents)
(package-install 'use-package))
#+END_SRC
** Generic packages
Here I install some packages that don't need configuration.
Remember to run M-x all-the-icons-install-fonts after the first
init to install the fonts.
#+BEGIN_SRC elisp
(use-package markdown-mode
:defer 1
:ensure t
:init(add-hook 'markdown-mode-hook 'auto-fill-mode))
(use-package all-the-icons
:defer 1
:ensure t)
(use-package which-key
:ensure t
:init (which-key-mode))
#+END_SRC
* Autoindentation
C-c n for indent-buffer. I don't use the rest.
#+BEGIN_SRC emacs-lisp
(setq-default tab-width 5)
(defvaralias 'sgml-basic-offset 'tab-width)
(add-hook 'html-mode-hook
(lambda ()
(set-fill-column 100)))
(defun indent-buffer ()
(interactive)
(save-excursion
(indent-region (point-min) (point-max) nil)))
(global-set-key (kbd "C-c n") 'indent-buffer)
;; C bullshit
(c-set-offset 'arglist-cont-nonempty '+)
#+END_SRC
* Shorcuts
Probably this overwrites another keybinding. But since I overwrited
it. I don't think i'd ever use the overwritten.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "M-m") 'mark-whole-buffer)
(global-set-key (kbd "C-c m") 'man)
(define-key org-mode-map (kbd "C-c p") 'org-publish-current-file)
(set-frame-font "Hack 17")
#+END_SRC
* No idea
#+BEGIN_SRC emacs-lisp
(setq package-enable-at-startup nil) (package-initialize)
(setq make-backup-files nil) ; stop creating backup~ files
(setq auto-save-default nil) ; stop creating #autosave# files
(put 'upcase-region 'disabled nil)
(defun contextual-menubar (&optional frame)
"Display the menubar in FRAME (default: selected frame) if on a
graphical display, but hide it if in terminal."
(interactive)
(set-frame-parameter frame 'menu-bar-lines
(if (display-graphic-p frame)
1 0)))
(add-hook 'after-make-frame-functions 'contextual-menubar)
(use-package zencoding-mode
:ensure t
:defer 1)
#+END_SRC
* My functions
Functions I wrote because emacs lisp is cool and useful.
#+begin_src emacs-lisp
(defun sosa/goto-previous-buffer ()
"Switch to the previous buffer."
(interactive)
(switch-to-buffer (other-buffer)))
(defun sosa/kill-inner-word ()
"Unlike (kill-word) function, this function actually kill a world."
(interactive)
(forward-char 1)
(backward-word)
(kill-word 1))
(defun sosa/no-lines()
"Locally disable number line mode, useful hooks."
(display-line-numbers-mode -1))
(defun sosa/git-pushall ()
"Call the git pushall shell command."
(interactive)
(shell-command "git pushall"))
(defun sosa/goto-dashboard ()
"Goes to the dashboard buffer"
(interactive)
(switch-to-buffer "*dashboard*")
(dashboard-mode)
(dashboard-refresh-buffer))
(setq org-publish-project-alist
'(("suragu.net"
:base-directory "~/docs/qorg_qorg/"
:publishing-directory "~/docs/mounts/sites/suragu.net"
:section-numbers nil
:publishing-function org-html-publish-to-html
:table-of-contents nil
:recursive t
)))
(defun sosa/make-website ()
"Publish the .org files of suragu.net to the sshfs mountpoint"
(interactive)
(org-publish "suragu.net"))
(defun run-current-file ()
"Execute or compile the current file.
For example, if the current buffer is the file x.pl,
then it'll call “perl x.pl” in a shell.
The file can be php, perl, python, bash, java.
File suffix is used to determine what program to run."
(interactive)
(let (ext-map file-name file-ext prog-name cmd-str)
; get the file name
; get the program name
; run it
(setq ext-map
'(
("php" . "php")
("pl" . "perl")
("py" . "python")
("p6" . "raku")
("raku" . "raku")
("sh" . "bash")
("java" . "javac")
)
)
(setq file-name (buffer-file-name))
(setq file-ext (file-name-extension file-name))
(setq prog-name (cdr (assoc file-ext ext-map)))
(setq cmd-str (concat prog-name " " file-name))
(shell-command cmd-str)))
#+end_src
* Programs
Emacs customization, Here is where most of the configuration is.
** Pseudopersonalization
Sane defaults!!!
#+BEGIN_SRC emacs-lisp
(tool-bar-mode -1)
(menu-bar-mode -1)
(scroll-bar-mode -1)
(global-hl-line-mode)
(set-face-background hl-line-face "#434343")
(setq-default cursor-type 'box)
(blink-cursor-mode 1)
(setq-default major-mode 'text-mode)
(defalias 'yes-or-no-p 'y-or-n-p)
;; Are you experienced?
(set-face-background 'line-number nil)
(set-face-background 'line-number-current-line nil)
(setq-default Man-notify-method 'pushy)
#+END_SRC
** Highlight matching parentheses
Useful for programming in lisp. I don't program in Lisp, but well.
#+BEGIN_SRC emacs-lisp
(show-paren-mode 1)
(setq show-paren-style 'mixed)
(setq startup/gc-cons-threshold gc-cons-threshold)
(setq gc-cons-threshold most-positive-fixnum)
(defun startup/reset-gc () (setq gc-cons-threshold startup/gc-cons-threshold))
(add-hook 'emacs-startup-hook 'startup/reset-gc)
#+END_SRC
** Tramp mode shit
(basically) no limit for remote files.
#+begin_src emacs-lisp
(set-variable 'tramp-copy-size-limit 122222222222)
(set-variable 'tramp-inline-compress-start-size 12222222222222)
#+end_src
** Lines and columns
Show relative lines in each file. Also display the column in the
minibuffer.
#+BEGIN_SRC emacs-lisp
(global-display-line-numbers-mode 1)
(setq display-line-numbers-type 'relative)
(column-number-mode 1)
#+END_SRC
** Flycheck
Flycheck is a syntax validator and lintern for programming.
#+BEGIN_SRC emacs-lisp
(use-package flycheck
:ensure t
:init
(add-hook 'after-init-hook #'global-flycheck-mode))
#+END_SRC
And for raku
#+BEGIN_SRC emacs-lisp
(use-package flycheck-raku
:ensure t
:init
(add-hook 'raku-mode 'flycheck-raku-mode))
#+END_SRC
** Terminal
vterm is better than ansi-term and shit, despite it's kinda slow,
it's a price i'm willing to pay. Remember that to compile VTerm you
need =cmake= installed. See the error buffer that is created everytime
you try to copmile vterm for further information.
It should use your default shell by default.
#+BEGIN_SRC emacs-lisp
(use-package "vterm"
:ensure t)
#+END_SRC
And to have multiple buffers
#+BEGIN_SRC emacs-lisp
(use-package multi-vterm
:ensure t
:bind("C-x C-t" . multi-vterm))
#+END_SRC
** Theme
#+begin_src emacs-lisp
(use-package "exotica-theme"
:ensure t
:init(load-theme 'exotica t)
)
(set-cursor-color "purple")
#+end_src
** ctrlf
So, you know, C-s in emacs sucks, so this is a repleacement for that.
#+BEGIN_SRC emacs-lisp
(use-package ctrlf
:ensure t
:defer 1
:init
(ctrlf-mode +1))
#+END_SRC
** Company and Irony
Some shit for autocompletion and that kind of shit.
** Programming language things
*** Lisp
Parentheses highlight in lisp modes. So you can easily identify
them.
#+BEGIN_SRC emacs-lisp
(use-package rainbow-delimiters
:ensure t
:init
(add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode)
(add-hook 'lisp-mode-hook 'rainbow-delimiters-mode)
(add-hook 'scheme-mode-hook 'rainbow-delimiters-mode))
(setq lisp-indent-offset 5)
#+END_SRC
*** Perl
I use LSP for perl.
#+BEGIN_SRC emacs-lisp
(setq perl-indent-level 5)
(defalias 'perl-mode 'cperl-mode)
(add-hook 'perl-mode-hook (lambda ()
(lsp)
(irony-mode -1)))
#+END_SRC
*** C*
This use c-eldoc mode so it prints the function's prototype in the
minibuffer. Which is very useful since Irony works when it wants
to. LSP is also used for further Programming.
#+BEGIN_SRC emacs-lisp
(use-package c-eldoc
:ensure t
:init
(add-hook 'c-mode-hook 'c-turn-on-eldoc-mode))
(setq c-default-style "k&r")
(add-hook 'c-mode-hook (lambda ()
(lsp)
(irony-mode -1)))
#+END_SRC
*** Raku
Raku, the cornerstone of any well designed programming language.
#+begin_src emacs-lisp
(setq raku-indent-offset 5)
(setq raku-exec-path "/usr/bin/raku")
#+end_src
*** HTML & CSS offset
#+begin_src emacs-lisp
(setq css-indent-offset 5)
(setq sgml-basic-offset 5)
#+end_src
*** org
#+begin_src emacs-lisp
(setq org-ellipsis " ")
(setq org-src-fontify-natively t)
(setq org-src-tab-acts-natively t)
(setq org-confirm-babel-evaluate nil)
(setq org-export-with-smart-quotes t)
(setq org-src-window-setup 'current-window)
(add-hook 'org-mode-hook 'org-indent-mode)
(add-hook 'org-mode-hook 'sosa/no-lines)
;; Syntax highlighting in exports
(use-package htmlize
:ensure t)
(setq org-html-head ""
org-html-head-extra ""
org-html-head-include-default-style nil
org-html-head-include-scripts nil
org-html-preamble nil
org-html-postamble nil
org-html-use-infojs nil)
#+end_src
** Keybindings
Here I put functions I won't bother to document because they're so
simple.
#+BEGIN_SRC emacs-lisp
(global-set-key (kbd "M-d") 'sosa/kill-inner-word)
(global-set-key (kbd "M-.") 'repeat)
(global-set-key (kbd "C-x k") 'kill-buffer)
(global-set-key (kbd "C-x C-k") 'kill-current-buffer)
(global-unset-key (kbd "C-x C-b"))
(global-set-key (kbd "C-x C-b") 'sosa/goto-previous-buffer)
#+END_SRC
** Hunspell
For some reason, there is no ispell spanish in void linux. so i had
to fallback to hunspell. which does the same.
#+BEGIN_SRC emacs-lisp
(defvar ispell-program-name "hunspell") ;; Or whatever you use
;; (ispell, aspell...)
#+END_SRC
** Dired
Ahhh, the emacs file browser, better than ranger and others...
Hide dotfiles:
#+BEGIN_SRC emacs-lisp
(use-package dired-hide-dotfiles
:ensure t
:init
(defun my-dired-mode-hook ()
"My `dired' mode hook."
;; To hide dot-files by default
(dired-hide-dotfiles-mode)
;; To toggle hiding
(define-key dired-mode-map "." #'dired-hide-dotfiles-mode))
(add-hook 'dired-mode-hook #'my-dired-mode-hook))
(use-package async
:ensure t
:init (dired-async-mode 1))
(add-hook 'dired-mode-hook
(lambda ()
(dired-hide-details-mode)))
#+END_SRC
Now let's make the thing lysergic
#+begin_src emacs-lisp
(set-face-foreground dired-directory-face "orange")
(set-face-foreground dired-symlink-face "cyan")
(set-face-foreground dired-mark-face "green")
(set-face-foreground dired-marked-face "blue")
#+end_src
** kill ring popup
#+BEGIN_SRC emacs-lisp
(use-package popup-kill-ring
:ensure t
:bind ("M-y" . popup-kill-ring))
#+END_SRC
** scrolling
Scroll by lines rather than by pages.
#+begin_src emacs-lisp
(setq scroll-step 1)
(setq scroll-conservatively 10000)
(setq auto-window-vscroll nil)
(scroll-bar-mode 1)
#+end_src
** Shell
#+begin_src emacs-lisp
(add-hook 'shell-mode-hook 'yas-minor-mode)
(add-hook 'shell-mode-hook 'flycheck-mode)
(add-hook 'shell-mode-hook 'company-mode)
(defun shell-mode-company-init ()
(setq-local company-backends '((company-shell
company-shell-env
company-etags
company-dabbrev-code))))
(use-package company-shell
:ensure t
:config
(require 'company)
(add-hook 'shell-mode-hook 'shell-mode-company-init))
#+end_src
** Mark multiple
Multiple cursors :DD
#+begin_src emacs-lisp
(use-package "multiple-cursors"
:ensure t
:bind ("C-c q" . 'mc/mark-next-like-this))
#+end_src
** Highlight indent guides
I don't really know, it looks cool.
#+begin_src emacs-lisp
(use-package "highlight-indent-guides"
:ensure t
:defer
:init (add-hook 'prog-mode-hook 'highlight-indent-guides-mode)
(setq highlight-indent-guides-method 'bitmap))
#+end_src
** Ace jump mode
Run, live to fly
Fly to live, do or die
Won't you run, live to fly
Fly to live, aces high
#+begin_src emacs-lisp
(use-package "ace-jump-mode"
:ensure t
:bind("C-l" . 'ace-jump-mode))
#+end_src
And same but jumping between frames
#+begin_src emacs-lisp
(use-package "ace-window"
:ensure t
:bind("M-l" . 'ace-window)
:bind("M-o" . 'ace-delete-window))
;; Gotta remove the bad habits
(global-unset-key (kbd "C-x o"))
#+end_src
** Expand region
#+begin_src emacs-lisp
(use-package expand-region
:ensure t
:init(global-unset-key (kbd "C-q"))
(global-set-key (kbd"C-q") 'er/expand-region))
(defun sosa/mark-words-between-quotes ()
"Does that."
(interactive)
(er/expand-region 2))
(global-set-key (kbd "C-c q") 'sosa/mark-words-between-quotes)
#+end_src
** Beacon mode
#+begin_src emacs-lisp
(use-package "beacon"
:ensure t
:init(beacon-mode 1))
#+end_src
** LSP
Le language server
#+begin_src emacs-lisp
(use-package "lsp-mode"
:ensure t)
(use-package "lsp-ui"
:ensure t
:init(add-hook 'lsp-mode-hook 'lsp-ui-mode))
#+end_src
** Hooks
I am tired of =M-x auto-fill-mode= in some modes
#+begin_src emacs-lisp
(add-hook 'org-mode-hook 'auto-fill-mode)
(add-hook 'text-mode-hook 'auto-fill-mode)
(add-hook 'sgml-mode-hook 'auto-fill-mode)
(add-hook 'sgml-mode-hook 'zencoding-mode)
(add-hook 'Man-mode-hook 'sosa/no-lines)
(add-hook 'speedbar-mode-hook 'sosa/no-lines)
#+end_src
** Hungry delete
Having to delete multiple whitespaces is one of the things I hate,
thankfully there's this thing.
#+begin_src emacs-lisp
(use-package "hungry-delete"
:ensure t
:init(global-hungry-delete-mode))
#+end_src
** Yasnippet
#+begin_src emacs-lisp
(use-package "yasnippet"
:ensure t
:config
(use-package "yasnippet-snippets"
:ensure t)
:init(yas-global-mode)
(yas-reload-all))
#+end_src
** Org-mode customization
#+begin_src emacs-lisp
(use-package "org-bullets"
:ensure t
:config
(add-hook 'org-mode-hook 'org-bullets-mode))
(local-unset-key (kbd"C-c C-q"))
(set-face-font 'org-level-1 "IBM Plex Mono 16")
(set-face-font 'org-level-2 "IBM Plex Mono 15")
(set-face-font 'org-level-3 "IBM Plex Mono 14")
#+end_src
** zzz-to-char
It's like ace-whatever but for zapping characters.
=zap-to-char=
#+begin_src emacs-lisp
(use-package zzz-to-char
:ensure t
:bind("M-z" . 'zzz-up-to-char))
#+end_src
** Helpful
Better \*help\* buffer
#+begin_src emacs-lisp
(use-package helpful
:ensure t
:bind ("C-h f". #'helpful-callable)
:bind ("C-h v". #'helpful-variable)
:bind ("C-h k". #'helpful-key))
#+end_src
** Treemacs
Sidebar xdxd
#+begin_src emacs-lisp
(use-package treemacs
:ensure t
:defer t
:init
(with-eval-after-load 'winum
(define-key winum-keymap (kbd "M-0") #'treemacs-select-window))
:config
(progn
(setq treemacs-collapse-dirs (if treemacs-python-executable 3 0)
treemacs-deferred-git-apply-delay 0.5
treemacs-directory-name-transformer #'identity
treemacs-display-in-side-window t
treemacs-eldoc-display 'simple
treemacs-file-event-delay 5000
treemacs-file-extension-regex treemacs-last-period-regex-value
treemacs-file-follow-delay 0.2
treemacs-file-name-transformer #'identity
treemacs-follow-after-init t
treemacs-expand-after-init t
treemacs-find-workspace-method 'find-for-file-or-pick-first
treemacs-git-command-pipe ""
treemacs-goto-tag-strategy 'refetch-index
treemacs-indentation 2
treemacs-indentation-string " "
treemacs-is-never-other-window nil
treemacs-max-git-entries 5000
treemacs-missing-project-action 'ask
treemacs-move-forward-on-expand nil
treemacs-no-png-images nil
treemacs-no-delete-other-windows t
treemacs-project-follow-cleanup nil
treemacs-persist-file (expand-file-name ".cache/treemacs-persist" user-emacs-directory)
treemacs-position 'left
treemacs-read-string-input 'from-child-frame
treemacs-recenter-distance 0.1
treemacs-recenter-after-file-follow nil
treemacs-recenter-after-tag-follow nil
treemacs-recenter-after-project-jump 'always
treemacs-recenter-after-project-expand 'on-distance
treemacs-litter-directories '("/node_modules" "/.venv" "/.cask")
treemacs-show-cursor nil
treemacs-show-hidden-files t
treemacs-silent-filewatch nil
treemacs-silent-refresh nil
treemacs-sorting 'alphabetic-asc
treemacs-select-when-already-in-treemacs 'move-back
treemacs-space-between-root-nodes t
treemacs-tag-follow-cleanup t
treemacs-tag-follow-delay 1.5
treemacs-text-scale nil
treemacs-user-mode-line-format nil
treemacs-user-header-line-format nil
treemacs-wide-toggle-width 70
treemacs-width 25
treemacs-width-increment 1
treemacs-width-is-initially-locked t
treemacs-workspace-switch-cleanup nil)
;; The default width and height of the icons is 22 pixels. If you are
;; using a Hi-DPI display, uncomment this to double the icon size.
;;(treemacs-resize-icons 44)
(treemacs-follow-mode t)
(treemacs-filewatch-mode t)
(treemacs-fringe-indicator-mode 'always)
(pcase (cons (not (null (executable-find "git")))
(not (null treemacs-python-executable)))
(`(t . t)
(treemacs-git-mode 'deferred))
(`(t . _)
(treemacs-git-mode 'simple)))
(treemacs-hide-gitignored-files-mode nil))
:bind
(:map global-map
("M-0" . treemacs-select-window)
("C-x t 1" . treemacs-delete-other-windows)
("C-x t t" . treemacs)
("C-x t d" . treemacs-select-directory)
("C-x t B" . treemacs-bookmark)
("C-x t C-t" . treemacs-find-file)
("C-x t M-t" . treemacs-find-tag)))
(use-package treemacs-projectile
:after (treemacs projectile)
:ensure t)
(use-package treemacs-icons-dired
:hook (dired-mode . treemacs-icons-dired-enable-once)
:ensure t)
(use-package treemacs-tab-bar ;;treemacs-tab-bar if you use tab-bar-mode
:after (treemacs)
:ensure t
:config (treemacs-set-scope-type 'Tabs))
#+end_src
** Projectile
Projectile is a project manager which helps you with git and stuff.
#+begin_src emacs-lisp
(use-package projectile
:ensure t
:init(projectile-mode))
#+end_src
** Ack
Ack is a replacement for =grep(1)= written in Perl, it's fast and
stuff. And has support for Perl regular expressions. Because it is
written in Perl.
#+begin_src emacs-lisp
(use-package "ack"
:ensure t
)
#+end_src
** Nyancat
Yes.
#+begin_src emacs-lisp
(use-package nyan-mode
:ensure t
:init(nyan-mode))
#+end_src
* Vertico
Better interactive selection minibuffer. Alternative to ido and
helm. This also installs =marginalia-mode=. So you can have further
information of the commands, files and stuff in the minibuffer.
#+begin_src emacs-lisp
(use-package marginalia
:ensure t)
(use-package vertico
:ensure t
:init
(vertico-mode)
(marginalia-mode)
;; Different scroll margin
(setq vertico-scroll-margin 10)
;; Show more candidates
(setq vertico-count 10)
;; Grow and shrink the Vertico minibuffer
(setq vertico-resize nil)
;; Optionally enable cycling for `vertico-next' and `vertico-previous'.
(setq vertico-cycle nil))
;; Persist history over Emacs restarts. Vertico sorts by history position.
(use-package savehist
:init
(savehist-mode))
;; A few more useful configurations
(use-package emacs
:ensure t
:init
;; Add prompt indicator to `completing-read-multiple'.
;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
(defun crm-indicator (args)
(cons (format "[CRM%s] %s"
(replace-regexp-in-string
"\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
crm-separator)
(car args))
(cdr args)))
(advice-add #'completing-read-multiple :filter-args #'crm-indicator)
;; Do not allow the cursor in the minibuffer prompt
(setq minibuffer-prompt-properties
'(read-only t cursor-intangible t face minibuffer-prompt))
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
;; Emacs 28: Hide commands in M-x which do not work in the current mode.
;; Vertico commands are hidden in normal buffers.
;; (setq read-extended-command-predicate
;; #'command-completion-default-include-p)
;; Enable recursive minibuffers
(setq enable-recursive-minibuffers t))
(advice-add #'vertico--format-candidate :around
(lambda (orig cand prefix suffix index _start)
(setq cand (funcall orig cand prefix suffix index _start))
(concat
(if (= vertico--index index)
(propertize "-> " 'face 'vertico-current)
" ")
cand)))
(defun vertico-resize--minibuffer ()
(add-hook 'window-size-change-functions
(lambda (win)
(let ((height (window-height win)))
(when (/= (1- height) vertico-count)
(setq-local vertico-count (1- height))
(vertico--exhibit))))
t t))
(advice-add #'vertico--setup :before #'vertico-resize--minibuffer)
#+end_src
* CRUX
This thing add sane shortcuts for emacs
#+begin_src emacs-lisp
(use-package "crux"
:ensure t
:bind("C-k" . 'crux-smart-kill-line)
:bind("C-c o" . 'crux-open-with)
:bind("C-c D" . 'crux-delete-buffer-and-file)
:bind("C-x C-r" . 'crux-reopen-as-root)
:bind("C-x C-d" . 'crux-duplicate-current-line-or-region)
:bind("C-c u" . 'crux-view-url)
:bind("C-c s" . 'crux-create-scratch-buffer))
#+end_src
* Dashboard
The dashboard is a good index for your things. So it's useful to have
it
Here is an useful function I wrote so you can go to the dashboard (Or
create it in case you accidentally killed the buffer)
#+begin_src emacs-lisp
(global-set-key (kbd "C-c C-d") 'sosa/goto-dashboard)
#+end_src
#+BEGIN_SRC emacs-lisp
(use-package dashboard
:ensure t
:init
(dashboard-setup-startup-hook)
(setq dashboard-items '(
(recents . 7)
(bookmarks . 7)
))
(setq dashboard-startup-banner 'logo)
(setq dashboard-banner-logo-title "Welcome to Editor MACroS")
(setq dashboard-startup-banner "~/.emacs.d/img/banner.png")
(setq dashboard-set-heading-icons t)
(setq dashboard-set-file-icons t))
#+END_SRC
* Modeline
#+begin_src emacs-lisp
(use-package "doom-modeline"
:ensure t
:init(doom-modeline-mode)
:config
(setq doom-modeline-height 25)
(setq doom-modeline-hud nil)
(setq doom-modeline-icon t)
(setq doom-modeline-major-mode-icon nil)
(setq doom-modeline-time-icon nil)
(setq doom-modeline-env-version t)
(setq doom-modeline-env-python-executable "python")
(setq doom-modeline-env-perl-executable "perl")
)
#+end_src
Reference in a new issue View git blame Copy permalink