dot-emacs

;; Copyright (C) 2025 Björn A. Lindqvist <bjourne@gmail.com>
;;
;; The idea is to replace the contents of .emacs with
;;
;;	(load-file "~/pubwork/ConfigurationFiles/dot-emacs")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; XDG & package initialization
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(setq config-base "~/.config/emacs/")
(setq package-user-dir (concat config-base "packages/"))

;; Must call this
(require 'package)

(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/") t)
;;(package-refresh-contents)
(package-initialize)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Startup config
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq inhibit-startup-message t)
(setq inhibit-splash-screen t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Frame customization -- widget removal
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(menu-bar-mode -1)
(scroll-bar-mode -1)
(tool-bar-mode -1)
(setq frame-title-format "%b")
(setq icon-title-format frame-title-format)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; frame splitting
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; I prefer to split side-by-side rather than on top and below.

(defun split-window-sensibly-prefer-horiz (&optional window)
  (let ((window (or window (selected-window))))
    (or (and (window-splittable-p window t)
             ;; Split window horizontally
             (with-selected-window window
               (split-window-right)))
        (and (window-splittable-p window)
             ;; Split window vertically
             (with-selected-window window
               (split-window-below)))
        (and
         ;; If WINDOW is the only usable window on its frame (it is
         ;; the only one or, not being the only one, all the other
         ;; ones are dedicated) and is not the minibuffer window, try
         ;; to split it horizontally disregarding the value of
         ;; `split-height-threshold'.
         (let ((frame (window-frame window)))
           (or
            (eq window (frame-root-window frame))
            (catch 'done
              (walk-window-tree (lambda (w)
                                  (unless (or (eq w window)
                                              (window-dedicated-p w))
                                    (throw 'done nil)))
                                frame)
              t)))
         (not (window-minibuffer-p window))
         (let ((split-width-threshold 0))
           (when (window-splittable-p window t)
             (with-selected-window window
               (split-window-right))))))))

(defun split-window-really-sensibly (&optional win)
  (let ((win (or win (selected-window))))
    (if (> (window-total-width win) (* 2 (window-total-height win)))
        (with-selected-window win (split-window-sensibly-prefer-horiz win))
      (with-selected-window win (split-window-sensibly win)))))

(setq
   split-height-threshold 80
   split-width-threshold 160
   split-window-preferred-function 'split-window-really-sensibly)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; dired customization
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package dired-x)

(use-package dired
  :init
  (setq dired-kill-when-opening-new-dired-buffer t)
  (setq dired-listing-switches "-agloA --group-directories-first")
  :bind (:map dired-mode-map
              ("h" . dired-up-directory)
              ("l" . dired-find-file))
  :hook ((dired-mode . (lambda() (load "dired-x")))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Improved fill-paragraph
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun toggle-filling ()
  (interactive)
  (let* ((reg-p (use-region-p))
	 (lo (if reg-p (region-beginning)
	       (save-excursion (backward-paragraph) (point))))
	 (hi (if reg-p (region-end)
	       (save-excursion (forward-paragraph) (point))))
	 (old (buffer-substring-no-properties lo hi)))
    (if (use-region-p)
	(fill-region lo hi)
      (fill-paragraph))
    (let* ((new (buffer-substring-no-properties lo hi))
	   (fill-column 9999))
      (when (string= new old)
	(if reg-p
	    (fill-region lo hi)
	  (fill-paragraph))))))

(global-set-key "\M-q" 'toggle-filling)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Improved navigation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun smarter-move-beginning ()
  (interactive)
  (let* ((at (point))
         (indent (save-excursion
                  (back-to-indentation)
                  (point))))
    (cond
     ((bolp)
      (if (bobp)
          (progn
            (beep)
            (message "Beginning of buffer"))
        (forward-line -1)
        (end-of-line)))
     ((<= at indent)
      (move-to-column 0))
     (t (back-to-indentation)))))


(defun smarter-move-end ()
  (interactive)
  (let* ((at (point))
         (indent (save-excursion
                  (back-to-indentation)
                  (point))))
    (cond
     ((eolp)
      (if (eobp)
          (progn
            (beep)
            (message "End of buffer"))
        (forward-line 1)
        (beginning-of-line)))
     ((< at indent)
      (back-to-indentation))
     (t (end-of-line)))))

(global-set-key [remap move-beginning-of-line] 'smarter-move-beginning)
(global-set-key [remap move-end-of-line] 'smarter-move-end)

(defun smarter-vl-move-end ()
  (interactive)
  (let ((eol (save-excursion
	       (end-of-visual-line 1)
	       (point))))
    (if (< (point) eol)
        (goto-char eol)
      (goto-char (+ eol 1)))))

(defun smarter-vl-move-beginning ()
  (interactive)
  (let ((bol (save-excursion
	       (beginning-of-visual-line 1)
	       (point))))
    (if (> (point) bol)
	(goto-char bol)
      (goto-char (- bol 1)))))

(define-key visual-line-mode-map (kbd "C-a") #'smarter-vl-move-beginning)
(define-key visual-line-mode-map (kbd "C-e") #'smarter-vl-move-end)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; OS specific configuration.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq is-windows (string-equal system-type "windows-nt"))

(if is-windows
    (progn (setq default-directory "C:\\")
           (add-to-list 'load-path "C:\\.emacs.d\\my-packages\\")
           (setq exec-path
                 (append exec-path '("C:/Program Files (x86)/Git/bin")))
           (setenv "GIT_ASKPASS" "git-gui--askpass"))
  (add-to-list 'load-path (expand-file-name "~/.config/emacs/mylisp")))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Personal details
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Setup personal info. This is to make ChangeLog mode work
(setq user-mail-address "bjourne@gmail.com")
(setq user-full-name "Björn Lindqvist")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Persistent scratch
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun save-persistent-scratch ()
  (with-current-buffer (get-buffer "*scratch*")
    (write-region (point-min) (point-max)
                  (concat config-base "scratch"))))

(defun load-persistent-scratch ()
  (if (file-exists-p (concat config-base "scratch"))
      (with-current-buffer (get-buffer "*scratch*")
        (delete-region (point-min) (point-max))
        (insert-file (concat config-base "scratch")))))

(load-persistent-scratch)
(push #'save-persistent-scratch kill-emacs-hook)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Strip trailing whitespace on save
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(add-hook 'before-save-hook 'delete-trailing-whitespace)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Which key is nice
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(which-key-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Set file which customization is written to
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq custom-file (locate-user-emacs-file "custom.el"))
(load custom-file)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Package management
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LSP, Flycheck, and Company
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package lsp-mode
  :ensure t
  :commands (lsp lsp-deferred)
  :init
  (setq lsp-keymap-prefix "C-c l")
  :config
  (lsp-enable-which-key-integration t))

(use-package company
  :ensure t
  :after lsp-mode
  :hook (lsp-mode . company-mode)
  :bind (:map company-mode-map
              ("M-SPC" . 'company-complete))
  :init
  ;; Don't autoshow the completion popup
  (setq company-minimum-prefix-length 1)
  (setq company-idle-delay nil))

(use-package flymake
  :bind (:map flymake-mode-map
              ("M-p" . flymake-goto-prev-error)
              ("M-n" . flymake-goto-next-error)))

(use-package flycheck
  :ensure t
  :after lsp-mode
  :bind (:map flycheck-mode-map
              ("M-p" . flycheck-previous-error)
              ("M-n" . flycheck-next-error)))


(use-package lsp-pyright
  :ensure t
  :custom
  (lsp-pyright-langserver-command "basedpyright")
  (lsp-pyright-type-checking-mode "off")
  :hook (python-mode . (lambda ()
                          (require 'lsp-pyright)
                          (lsp))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ido!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq ido-enable-flex-matching t
      ido-everywhere t)
(ido-mode t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CSS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package rainbow-mode :ensure t)

(use-package css-mode
  :init
  (setq css-indent-offset 4)
  :bind (:map css-mode-map
              ("C-c C-c" . css-cycle-color-format)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Misc stuff
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Mouse wheel
(mouse-wheel-mode t)

;; Minor modes I like
(column-number-mode t)

;; Setup tab-stop-list
(setq tab-stop-list
      (let ((i 4) list)
        (while (< i 80)
          (setq list (cons i list))
          (setq i (+ i 4)))
        (reverse list)))

;; Make text selections visible
(transient-mark-mode t)

;; Make it so yanked text is placed in xorg's clipboard buffer.
(setq x-select-enable-clipboard t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; verilog-mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package verilog-mode
  :bind (:map verilog-mode-map
              ([delete] . nil)
              ([backspace] . nil))
  :init
  (setq verilog-auto-endcomments nil)
  (setq verilog-auto-lineup nil)
  (setq verilog-cexp-indent 4)
  (setq verilog-indent-begin-after-if nil)
  (setq verilog-indent-level 4)
  (setq verilog-indent-level-declaration 4)
  (setq verilog-indent-level-module 4)
  (setq verilog-indent-lists nil))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Typescript
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package typescript-mode
  :mode "\\.ts\\'"
  :hook (typescript-mode . lsp-deferred)
  :config
  (setq typescript-indent-level 4))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; C-mode, Java, etc.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package cc-mode
  :init
  (setq tab-width 2
        indent-tabs-mode nil
        c-basic-offset 4))

(mapcar
 (lambda (x)
   (let* ((mode (car x))
          (exts (cdr x))
          (rx (concat "\\." (regexp-opt (append exts nil)) "\\'")))

     (add-to-list 'auto-mode-alist
                  `(,rx . ,mode))
   ))
 '((c++-mode .  ["h" "cuh" "cu"])
   (c-mode . ["cl"])))

(defun my-c-initialization-hook ()
  (c-set-offset 'substatement-open 0)
  (c-set-offset 'arglist-intro '+)
  (c-set-offset 'innamespace [0])
  (c-set-offset 'arglist-close 0)
  (c-set-offset 'cpp-macro 0)
  (define-key c-mode-base-map (kbd "C-c C-d") nil)
  (define-key c-mode-base-map (kbd "C-c C-d C-d") 'man-follow))
(add-hook 'c-mode-common-hook 'my-c-initialization-hook)

(add-hook 'java-mode-hook (lambda ()
                            (c-set-offset 'arglist-close 0)
                            (c-set-offset 'arglist-intro '+)
                            (c-set-offset 'class-close -1)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; c-ts-mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Preprocessor directives are annoying.
(defun my-c-ts-indent-style ()
  (let ((ofs c-ts-mode-indent-offset)
        (half-ofs (/ c-ts-mode-indent-offset 2)))
    `(
      ;; Always put these at col 0
      ((parent-is "translation_unit") column-0 0)

      ;; Don't indent function names
      ((node-is "function_declarator") column-0 0)

      ;; Preprocessor directives
      ((node-is "preproc_arg") column-0 ,ofs)
      ((node-is "preproc") column-0 0)
      ((node-is "#endif") column-0 0)

      ;; Like "retract"
      ((node-is ")") parent-bol 0)
      ((node-is "}") standalone-parent 0)
      ((parent-is "\\`declaration\\'") parent-bol 0)

      ;; Body
      ((parent-is "compound_statement") standalone-parent ,ofs)
      ;; Stupid hack for preprocessor
      ((n-p-gp nil "preproc" "compound_statement") standalone-parent ,ofs)

      ;; Magic stuff
      (c-ts-mode--for-each-tail-body-matcher prev-line ,ofs)
      (c-ts-mode--else-heuristic prev-line ,ofs)

      ;; This rule matches foo = \\nblah.
      ((parent-is "assignment_expression") parent-bol ,ofs)

      ;; Tertiary exprs
      ((node-is ":") (nth-sibling 1) 0)

      ;; Switch/case
      ((node-is "case") standalone-parent 0)
      ((parent-is "case_statement") standalone-parent ,ofs)

      ;; Goto labels
      ((node-is "labeled_statement") standalone-parent ,half-ofs)

      ;; For statements
      ((query "(for_statement initializer: (_) @indent)") parent-bol 5)
      ((query "(for_statement condition: (_) @indent)") parent-bol 5)
      ((query "(for_statement update: (_) @indent)") parent-bol 5)

      ;; If statements
      ((node-is "else") parent-bol 0)
      ((parent-is "if_statement") standalone-parent ,ofs)
      ((parent-is "else_clause") standalone-parent ,ofs)

      ;; While
      ((parent-is "while_statement") standalone-parent ,ofs)

      ;; Multi-line strings
      ((parent-is "concatenated_string") first-sibling 0)

      ;; Linup indentation or one-level indentation
      ((match nil "enumerator_list" nil 0 1) parent-bol ,ofs)
      ((match nil "enumerator_list" nil 2 nil) (nth-sibling 1) 0)

      ((match nil "parameter_list" nil 0 1) parent-bol ,ofs)
      ((match nil "parameter_list" nil 2 nil) (nth-sibling 1) 0)

      ((match nil "argument_list" nil 0 1) parent-bol ,ofs)
      ((match nil "argument_list" nil 2 nil) (nth-sibling 1) 0)

      ((match nil "initializer_list" nil 0 1) parent-bol ,ofs)
      ((match nil "initializer_list" nil 2 nil) (nth-sibling 1) 0)

      ((match nil "field_declaration_list" nil 0 1) parent-bol ,ofs)
      ((match nil "field_declaration_list" nil 2 nil) (nth-sibling 1) 0)

      ((match nil "parenthesized_expression" nil 0 1) parent-bol ,ofs)
      ((match nil "parenthesized_expression" nil 2 nil) (nth-sibling 1) 0)

      ;; IDK
      ((parent-is "binary_expression") parent 0)
      )
    )
  )

(use-package c-ts-mode
  :if (treesit-language-available-p 'c)
  :custom
  (c-ts-mode-indent-offset 4)
  (c-ts-mode-indent-style #'my-c-ts-indent-style)
  :init
  (add-hook 'c-ts-mode-hook
            (lambda ()
              (c-ts-mode-toggle-comment-style -1)))
  ;; Remap the standard C/C++ modes
  (add-to-list 'major-mode-remap-alist
               '(c-mode . c-ts-mode))
  (add-to-list 'major-mode-remap-alist
               '(c++-mode . c++-ts-mode))
  (add-to-list 'major-mode-remap-alist
               '(c-or-c++-mode . c-or-c++-ts-mode)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Auto saving backups. Fixed emacs bad defaults.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar saves-dir (expand-file-name "~/.local/state/emacs/"))

(setq backup-by-copying t)
(setq backup-directory-alist `((".*" . ,saves-dir)))
(setq auto-save-default t)
(setq auto-save-list-file-prefix (concat saves-dir "save-"))
(setq auto-save-file-name-transforms `((".*" ,saves-dir t)))

(setq delete-old-versions nil)
(setq kept-new-versions 6)
(setq kept-old-versions 2)
; use versioned backups
(setq version-control t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Better editing
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq kill-whole-line t)
(setq backward-delete-char-untabify-method 'all)

(defun copy-buffer-file-path()
  (interactive "*")
  (kill-new buffer-file-name))

(defun delete-horizontal-space-forward()
  (interactive "*")
  (setq first-point (point))
  (setq next-point (progn (skip-chars-forward " \t\n") (point)))
  (if (eq first-point next-point)
      (delete-char 1)
    (delete-region first-point next-point))
  )

;; End files with newlines
(setq require-final-newline t)
(setq next-line-add-newlines nil)


;; Better uniquify
(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)

(defun rename-file-and-buffer (new-name)
  "Renames both current buffer and file it's visiting to NEW-NAME."
  (interactive "FMove to file: ")
  (let ((name (buffer-name))
        (filename (buffer-file-name)))
    (if (not filename)
        (message "Buffer '%s' is not visiting a file!" name)
      (if (get-buffer new-name)
          (message "A buffer named '%s' already exists!" new-name)
        (progn
          (rename-file name new-name 1)
          (rename-buffer new-name)
          (set-visited-file-name new-name)
          (set-buffer-modified-p nil))))))

(defun pretty-print-xml-region (begin end)
  "Pretty format XML markup in region. You need to have nxml-mode
http://www.emacswiki.org/cgi-bin/wiki/NxmlMode installed to do
this.  The function inserts linebreaks to separate tags that have
nothing but whitespace between them.  It then indents the markup
by using nxml's indentation rules."
  (interactive "r")
  (save-excursion
    (goto-char begin)
    (while (search-forward-regexp "\>[ \\t]*\<" nil t)
      (backward-char) (insert "\n"))
    (indent-region begin end))
  (message "Ah, much better!"))

;; Improves performance on Windows
(setq w32-get-true-file-attributes nil)

(setq read-buffer-completion-ignore-case t)
(setq read-file-name-completion-ignore-case t)


(put 'downcase-region 'disabled nil)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Global keybindings
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global-set-key "\M-g" 'goto-line)

;; Dabbrev stuff
(global-set-key (kbd "M-SPC") 'hippie-expand)

;; comment-dwim on C-c c
(global-set-key (kbd "C-c c") 'comment-dwim)

;; Basic stuff
(global-set-key "\C-z" 'undo)
(global-set-key "\C-?" 'backward-delete-char-untabify)
(global-set-key [delete] 'delete-horizontal-space-forward)

;; Move between windows
(windmove-default-keybindings)

;; Ibuffer
(global-set-key (kbd "C-x C-b") 'ibuffer)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Magit
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package magit
  :ensure t
  :init
  (setq magit-last-seen-setup-instructions "1.4.0"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Shell
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package sh-mode
  :mode ("\\.conf$" "\\.zsh$"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Elisp
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package emacs-lisp-mode
  :mode ("dot-emacs$")
  :bind (:map emacs-lisp-mode-map
              ("C-t" . completion-at-point)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Python
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun tidy()
  (interactive)
  (shell-command-on-region
   (region-beginning)
   (region-end)
   "black -l 78 -" nil t "*Black*" nil))

(defun my-run-python (cmd &optional dedicated show)
  (interactive "P")
  (run-python cmd dedicated show)
  (switch-to-buffer-other-window "*Python*"))

;; Many auto mode alists
(use-package python-mode
  :ensure nil
  :mode ("SConstruct\\|SConscript\\|wscript\\|wscript_build")
  :bind (:map python-mode-map
              ("C-c C-p" . my-run-python)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; YAML
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package yaml-mode
  :mode ("\\.yml\\'"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Prolog
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package prolog-mode
  :mode "\\.pl\\'"
  :init
  (setq prolog-indent-width 4))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Markdown
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package markdown-mode
  :mode ("\\.md\\'")
  :bind (:map markdown-mode-map
	      ("C-e" . #'smarter-move-end)
	      ("C-a" . #'smarter-move-beginning)))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; VHDL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package vhdl-mode
  :init
  (setq vhdl-basic-offset 4)
  :hook (vhdl-mode . (lambda ()
                       (vhdl-set-offset 'arglist-close 0))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Octave
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'octave)
(add-to-list 'auto-mode-alist '("\\.m$" . octave-mode))
(define-key octave-mode-map (kbd "C-c C-z") 'run-octave)
(setq inferior-octave-prompt-read-only t)
(setq octave-block-offset 4)

;; https://emacs.stackexchange.com/questions/15164/commented-lines-shoot-off-to-column-32-in-octave-mode
(setq octave-mode-hook
      (lambda() (progn
                  (defun octave-indent-comment ()
                    "A function for `smie-indent-functions' (which see)."
                    (save-excursion
                      (back-to-indentation)
                      (cond
                       ((octave-in-string-or-comment-p) nil)
                       ((looking-at-p "\\(\\s<\\)\\1\\{2,\\}") 0)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; grep - highlight matches
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Had to hack vc-git.el to add --color=always to the git grep command.
(require 'grep)
(defun my-vc-git-grep ()
  (interactive)
  (vc-git-grep (grep-read-regexp) "*" (vc-git-root default-directory))
  (other-window 1))

(use-package vc
  :bind ("C-c g" . my-vc-git-grep))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Spelling
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(when is-windows
  (add-to-list 'exec-path "C:/Program Files (x86)/Aspell/bin/")
  (setq ispell-personal-dictionary "~/.ispell")
  (setq ispell-program-name "aspell")
  (require 'ispell))

;; Emacs spell-checking is unusable. :(
;; (add-hook 'text-mode-hook 'flyspell-mode)
(setq flyspell-issue-message-flag nil)

(defface ispell-alpha-num-choice-face
  '((t (:background "black" :foreground "red")))
  "Face for `ispell-alpha-num-choice-face`."
  :group 'ispell)

(defface ispell-text-choice-face
  '((t (:background "black" :foreground "forestgreen")))
  "Face for `ispell-text-choice-face`."
  :group 'ispell)

(defun set-language (code name)
  (let* ((dir (expand-file-name "~/.config/aspell/"))
         (pd (concat dir code ".pws"))
         (rd (concat dir code ".prepl")))
    (make-directory dir t)
    (setq ispell-personal-dictionary pd)
    (setq ispell-extra-args (list "--repl" rd)))
  (ispell-change-dictionary code)
  (flyspell-buffer)
  (message (format "Switched to %s" name)))

;; This nice code comes from https://stackoverflow.com/questions/27544869/how-do-i-change-ispell-private-dictionary
(defun my-ispell-change-dictionaries ()
  "Switch between language dictionaries."
  (interactive)
  (let ((choice (read-char-exclusive (concat
                                      "["
                                      (propertize "E" 'face 'ispell-alpha-num-choice-face)
                                      "]"
                                      (propertize "nglish" 'face 'ispell-text-choice-face)
                                      " | ["
                                      (propertize "S" 'face 'ispell-alpha-num-choice-face)
                                      "]"
                                      (propertize "venska" 'face 'ispell-text-choice-face)))))
    (cond
     ((eq choice ?E)
      (set-language "en" "English"))
     ((eq choice ?S)
      (set-language "sv" "Svenska"))
     (t (message "No changes have been made."))) ))

;; Keybinding to cycle between languages.
(add-hook 'flyspell-mode-hook
          (lambda ()
            (set-language "en" "English")
            (local-set-key (kbd "C-c l") 'my-ispell-change-dictionaries)
            (local-set-key (kbd "C-c a") 'flyspell-correct-word-before-point)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Solarized theme
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package solarized-theme)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Theme, fonts and faces.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Helper functions to make it easier to select the right
;; customization for a particular computer.
(defun read-proc-cpuinfo ()
  (with-temp-buffer
  (insert-file-contents "/proc/cpuinfo")
  (when (re-search-forward "^model name[\t\s]*: \\(.*\\)$" nil t)
    (match-string 1))))

(defun device-identity ()
  (cond
   ((file-readable-p "/proc/cpuinfo")
    (read-proc-cpuinfo))
   ;; Fallback to host name if /proc/cpuinfo can't be read.
   (t (system-name))))

;; Inconsolata with italic and bold variants:
;;    https://github.com/MihailJP/Inconsolata-LGC
;; Comic Mono:
;;    https://github.com/dtinth/comic-mono-font
;; Monaco:
;;    https://github.com/mps/fonts/blob/master/MONACO.TTF
(setq-local device-configs
            '(
              ("Intel(R) Core(TM) Ultra 9 185H" .
               ("Inconsolata LGC 12"
                "~/"
                ["p/ConfigurationFiles/dot-emacs"
                 "p/ConfigurationFiles/zshrc"]))
              ("Intel(R) Xeon(R) W-2245 CPU @ 3.90GHz" .
               ("Monaco 23" "~/"
                ["p/ConfigurationFiles/dot-emacs"
                 "p/ConfigurationFiles/zshrc"
                 "c/html/test.css"
                 ]))
              ("unknown" .
               ("Inconsolata LGC 15" "~/" []))
              )
            )
(setq-local device-config
            (cdr (assoc (device-identity) device-configs)))
(setq-local device-font (nth 0 device-config))
(setq-local device-auto-open-root (nth 1 device-config))
(setq-local device-auto-open-files (nth 2 device-config))

;; Theme, possibly a different init should be used on windows.
(global-font-lock-mode t)

;; Stop unnecessary warnings
(setq custom-safe-themes t)

(defun gui-theme ()
  (set-face-attribute 'default nil
                      :font device-font)
  (when (string= (device-identity) "Intel(R) Core(TM) Ultra 9 185H")
    (progn (load-theme 'solarized-dark)
           (setq-default line-spacing 8)))
  (when (string= (device-identity) "Intel(R) Xeon(R) W-2245 CPU @ 3.90GHz")
    (setq-default line-spacing 4))
  )

(defun console-theme ()
  (custom-set-faces
     '(font-lock-comment-face ((t (:foreground "black" :weight bold))))
     '(font-lock-constant-face ((t (:foreground "magenta" :weight bold))))
     '(font-lock-keyword-face ((t (:foreground "magenta"))))
     '(font-lock-preprocessor-face ((t (:foreground "red"))))
     '(font-lock-string-face ((t (:foreground "yellow"))))
     '(font-lock-type-face ((t (:foreground "cyan"))))
     '(font-lock-variable-name-face
       ((t (:foreground "cyan" :weight bold))))))

(if (display-graphic-p)
   (gui-theme)
  (console-theme))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Run the server
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(server-start)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Desktop mode and frame configuration
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Not sure, but it might be important that the desktop is loaded
;; after all packages are configured.
(setq
 desktop-path '("~/.config/emacs/")
 ;; I'd like to override the name of the lock file too, but there is
 ;; no good interface for that.
 desktop-base-file-name "desktop.el")
(desktop-save-mode 1)

(setq frame-resize-pixelwise t)
(add-to-list 'default-frame-alist '(fullscreen . fullboth))