Permalink
Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
690 lines (596 sloc) 24 KB

Starter Kit Defuns

This is part of the Emacs Starter Kit.

My Defuns

Function definitions

(require 'thingatpt)
(require 'imenu)

Transparency

Functions to interactively modify Emacs transparency.

  (add-to-list 'default-frame-alist '(alpha . (93)))

;; interactive transparency
(defun transparency-set-initial-value ()
  "Set initial value of alpha parameter for the current frame"
  (interactive)
  (if (equal (frame-parameter nil 'alpha) nil)
      (set-frame-parameter nil 'alpha 93)))
      ;; (set-frame-parameter nil 'alpha 100)))

(transparency-set-initial-value)

(defun transparency-set-value (numb)
  "Set level of transparency for the current frame"
  (interactive "nEnter transparency level in range 0-100: ")
  (if (> numb 100)
      (message "Error! The maximum value for transparency is 100!")
    (if (< numb 0)
    (message "Error! The minimum value for transparency is 0!")
      (set-frame-parameter nil 'alpha numb))))

;; want to get message to pop up telling me what variable it's at
(defun transparency-increase ()
  "Increase level of transparency for the current frame"
  (interactive)
  (transparency-set-initial-value)
  (if (> (frame-parameter nil 'alpha) 0)
      (set-frame-parameter nil 'alpha (+ (frame-parameter nil 'alpha) -3))
    ;;       (message "Transparency set to ")
    (message "This is a minimum value of transparency!")))

(defun transparency-decrease ()
  "Decrease level of transparency for the current frame"
  (interactive)
  (transparency-set-initial-value)
  (if (< (frame-parameter nil 'alpha) 100)
      (set-frame-parameter nil 'alpha (+ (frame-parameter nil 'alpha) +3))
    (message "This is a minimum value of transparency!")))

My Latex matrix conversion defun

;;; Following functions by Chris Beard
;;; wcbeard10@gmail.com
(defun matrixify ()
  "Converts an org table to a matrix formatted in LaTeX."
  (interactive)
  (save-restriction 
    (narrow-to-region (my-table-top -1) (my-table-top))
    (goto-char (point-min))
    (while (search-forward-regexp "|\s*$" nil t) (replace-match "\\\\" nil t))
    (goto-char (point-min))
    (while (search-forward-regexp "^|" nil t) (replace-match " " nil t))
    (goto-char (point-min))
    (while (search-forward-regexp " | " nil t) (replace-match " & " nil t))
    (goto-char (point-min))
    (insert "\\\[ \\left(\n\\begin{matrix}\n")
    (goto-char (point-max))
    (insert "\n\\end{matrix}\n\\right) \\\]")
    (goto-char (point-min))
    ))

(defun xymatrixify ()
  "Converts an org table to a matrix formatted in LaTeX."
  (interactive)
  (save-restriction 
    (narrow-to-region (my-table-top -1) (my-table-top))
    (goto-char (point-min))
    (while (search-forward-regexp "|\s*$" nil t) (replace-match "\\\\" nil t))
    (goto-char (point-min))
    (while (search-forward-regexp "^|" nil t) (replace-match " " nil t))
    (goto-char (point-min))
    (while (search-forward-regexp " | " nil t) (replace-match " & " nil t))
    (goto-char (point-min))
    (insert "\\xymatrix\{\n")
    (goto-char (point-max))
    (insert "\n}")
    (goto-char (point-min))
    ))

(defun i-matrixify (arg)
  "Converts an org table to a matrix formatted in LaTeX. Takes an argument to specify delimiter: (, [ and |, etc give matrix with respective delimiters, but no environment enclosure (\\[ \\]), while p, b and v, etc. give same delimiters with the environment. If the delimiter is 'x,' then it will run the xymatrixify function."
  (interactive "cEnter matrix delimiter: ")
  (setq end-env "")
  (setq begin-env "")
  (cond
   ((equal (string arg) "|") (setq delim "v"))
   ((equal (string arg) "(") (setq delim "p"))
   ((equal (string arg) "[") (setq delim "b"))
   ((equal (string arg) "{") (setq delim "B"))
   ((equal (string arg) "=") (setq delim "V"))
   ((equal (string arg) " ") (setq delim ""))
   (t (progn
        (setq begin-env "\\\[\n")
        (setq end-env "\n\\\]")
        (setq delim (string arg)))))
  (if (equal delim "x")
      (xymatrixify)
    (save-restriction 
      (narrow-to-region (my-table-top -1) (my-table-top))
      (goto-char (point-min))
      (while (search-forward-regexp "|\s*$" nil t) (replace-match "\\\\" nil t))
      (goto-char (point-min))
      (while (search-forward-regexp "^|" nil t) (replace-match " " nil t))
      (goto-char (point-min))
      (while (search-forward-regexp " | " nil t) (replace-match " & " nil t))
      (goto-char (point-min))
      (insert (concat begin-env "\\begin{" delim "matrix}\n"))
      (goto-char (point-max))
      (insert (concat "\n\\end{" delim "matrix}" end-env))
      (goto-char (point-min)))))

(defun my-table-up-line (&optional arg)
  "Helper function that recursively goes to the beginning of the table if arg is 1 or absent, and to the end of table if -1. Returns final position."
  (if arg
      (setq val arg)
    (setq val 1))
  (next-line (* -1 val))
  (if (table-line?)
      (my-table-up-line val)
    (beginning-of-line (1+ val)))
  (unless (>= val 0)
    (end-of-line))
  (point))

(defun my-table-top (&optional arg)
  "my-table-up-line function wrapper, which gives error message if command isn't called from within a table"
  (interactive)
  (if arg
      (setq val arg)
    (setq val 1))
  ;; (beginning-of-line)
  (if (table-line?)
      (my-table-up-line (* 1 val))
    (message "Not in table")))

(defun table-line? ()
  (save-excursion
    (beginning-of-line)
    (equal (string (char-after (point))) "|")))

(defun unmatrixify (start end &optional arg)
  "Converts a LaTeX matrix to an org table, where arg is the number of lines before and after the matrix that are deleted; default 0. "
  (interactive "r")
  (if arg
      (progn
        (setq val arg)
        (insert "arg!"))
    (setq val 1))             ;; originally 2, testing with 0
  (save-excursion
    (save-restriction 
      (narrow-to-region start end)
      (goto-char (point-min))
      (while (search-forward-regexp "\\\\\\{2\\}" nil t) (replace-match "|" nil t))
      (goto-char (point-min))
      (while (search-forward-regexp "^ " nil t) (replace-match "| " nil t))
      (goto-char (point-min))
      (while (search-forward-regexp " & " nil t) (replace-match " | " nil t))
      (goto-char (point-min))))
  (goto-char end)
  (beginning-of-line (if (> val 0)
                         2
                       1))
  (kill-line val)
  (goto-char start)
  (kill-line (- 0 val)))

My Python defuns

Former python defuns.

;; https://github.com/EnigmaCurry/emacs/blob/master/ryan-python.el
;; http://www.enigmacurry.com/category/emacs/

Xah’s change case defun

;;=================
;;===CASE TOGGLE===
;;=================
;; http://xahlee.org/emacs/modernization_upcase-word.html

(defun toggle-letter-case ()
  "Toggle the letter case of current word or text selection.
Toggles from 3 cases: UPPER CASE, lower case, Title Case,
in that cyclic order."
  (interactive)

  (let (pos1 pos2 (deactivate-mark nil) (case-fold-search nil))
    (if (and transient-mark-mode mark-active)
        (setq pos1 (region-beginning)
              pos2 (region-end))
      (setq pos1 (car (bounds-of-thing-at-point 'word))
            pos2 (cdr (bounds-of-thing-at-point 'word))))

    (when (not (eq last-command this-command))
      (save-excursion
        (goto-char pos1)
        (cond
         ((looking-at "[[:lower:]][[:lower:]]") (put this-command 'state "all lower"))
         ((looking-at "[[:upper:]][[:upper:]]") (put this-command 'state "all caps") )
         ((looking-at "[[:upper:]][[:lower:]]") (put this-command 'state "init caps") )
         (t (put this-command 'state "all lower") )
         )
        )
      )

    (cond
     ((string= "all lower" (get this-command 'state))
      (upcase-initials-region pos1 pos2) (put this-command 'state "init caps"))
     ((string= "init caps" (get this-command 'state))
      (upcase-region pos1 pos2) (put this-command 'state "all caps"))
     ((string= "all caps" (get this-command 'state))
      (downcase-region pos1 pos2) (put this-command 'state "all lower"))
     )
    )
  )

Buffer-related

(defun ido-imenu ()
  "Update the imenu index and then use ido to select a symbol to navigate to.
Symbols matching the text at point are put first in the completion list."
  (interactive)
  (imenu--make-index-alist)
  (let ((name-and-pos '())
        (symbol-names '()))
    (flet ((addsymbols (symbol-list)
                       (when (listp symbol-list)
                         (dolist (symbol symbol-list)
                           (let ((name nil) (position nil))
                             (cond
                              ((and (listp symbol) (imenu--subalist-p symbol))
                               (addsymbols symbol))
                              
                              ((listp symbol)
                               (setq name (car symbol))
                               (setq position (cdr symbol)))
                              
                              ((stringp symbol)
                               (setq name symbol)
                               (setq position (get-text-property 1 'org-imenu-marker symbol))))
                             
                             (unless (or (null position) (null name))
                               (add-to-list 'symbol-names name)
                               (add-to-list 'name-and-pos (cons name position))))))))
      (addsymbols imenu--index-alist))
    ;; If there are matching symbols at point, put them at the beginning of `symbol-names'.
    (let ((symbol-at-point (thing-at-point 'symbol)))
      (when symbol-at-point
        (let* ((regexp (concat (regexp-quote symbol-at-point) "$"))
               (matching-symbols (delq nil (mapcar (lambda (symbol)
                                                     (if (string-match regexp symbol) symbol))
                                                   symbol-names))))
          (when matching-symbols
            (sort matching-symbols (lambda (a b) (> (length a) (length b))))
            (mapc (lambda (symbol) (setq symbol-names (cons symbol (delete symbol symbol-names))))
                  matching-symbols)))))
    (let* ((selected-symbol (ido-completing-read "Symbol? " symbol-names))
           (position (cdr (assoc selected-symbol name-and-pos))))
      (goto-char position))))

Yank ring auto-indent

(defvar yank-indent-modes '(emacs-lisp-mode
                            c-mode c++-mode
                            tcl-mode sql-mode
                            perl-mode cperl-mode
                            java-mode jde-mode
                            lisp-interaction-mode
                            LaTeX-mode TeX-mode)
  "Modes in which to indent regions that are yanked (or yank-popped)")

(defvar yank-advised-indent-threshold 1000
  "Threshold (# chars) over which indentation does not automatically occur.")

(defun yank-advised-indent-function (beg end)
  "Do indentation, as long as the region isn't too large."
  (if (<= (- end beg) yank-advised-indent-threshold)
      (indent-region beg end nil)))

(defadvice yank (after yank-indent activate)
  "If current mode is one of 'yank-indent-modes, indent yanked text (with prefix arg don't indent)."
  (if (and (not (ad-get-arg 0))
           (member major-mode yank-indent-modes))
      (let ((transient-mark-mode nil))
    (yank-advised-indent-function (region-beginning) (region-end)))))

(defadvice yank-pop (after yank-pop-indent activate)
  "If current mode is one of 'yank-indent-modes, indent yanked text (with prefix arg don't indent)."
  (if (and (not (ad-get-arg 0))
           (member major-mode yank-indent-modes))
    (let ((transient-mark-mode nil))
    (yank-advised-indent-function (region-beginning) (region-end)))))

Resize frames and navigating

  
;;===============================
;;===Resize windows and frames===
;;===============================
;; some kbd mixup with aquamacs
(defun gcm-scroll-down ()
  (interactive)
  (View-scroll-line-forward 9))
(defun gcm-scroll-up ()
  (interactive)
  (View-scroll-line-backward 9))

(defun big-move-down ()
  (interactive)
  (next-line 9))
(defun big-move-up ()
  (interactive)
  (previous-line 9))

Insert date and time

(global-set-key (kbd "C-c d") 'my-insert-date)

(defun my-insert-date ()
  "Insert the current date."
  (interactive)
  (insert (format-time-string "%d %B %Y")))

(defun insert-date (prefix)
  "Insert the current date. With prefix-argument, use ISO format. With
   two prefix arguments, write out the day and month name."
  (interactive "P")
  (let ((format (cond
                 ((not prefix) "%d %B %Y")
                 ((equal prefix '(4)) "%Y-%m-%d")
                 ((equal prefix '(16)) "%A, %d. %B %Y")
                 ))
        (system-time-locale "en_EN"))
    (insert (format-time-string format))))

Copy lines, etc

  
(defun select-next-window ()
  "Switch to the next window" 
  (interactive)
  (select-window (next-window)))

(defun select-previous-window ()
  "Switch to the previous window" 
  (interactive)
  (select-window (previous-window)))

					;(add-hook 'org-mode 'color-theme-inkpot)
;;when you try and do ^/_, it automatically includes braces
(setq TeX-electric-sub-and-superscript 1)
;;insert double "{}", hit C-c {
;;typset: C-c C-c

(add-hook 'paragraph-indent-text-mode-hook '(lambda ()
					      (local-set-key (kbd "RET") 'newline)))
					;(setq left-margin 0)

(defun copy-line (&optional arg)
  "Do a kill-line but copy rather than kill.  This function directly calls
    kill-line, so see documentation of kill-line for how to use it including prefix
    argument and relevant variables.  This function works by temporarily making the
    buffer read-only."
  (interactive "P")
  (let ((buffer-read-only t)
	(kill-read-only-ok t))
    (kill-line arg)))
;; optional key binding
;;    (global-set-key "\C-c\C-k" 'copy-line)

(defun copy-whole-line (&optional arg)
  "Do a kill-line but copy rather than kill.  This function directly calls
    kill-line, so see documentation of kill-line for how to use it including prefix
    argument and relevant variables.  This function works by temporarily making the
    buffer read-only."
  (interactive "P")
  (let ((buffer-read-only t)
	(kill-read-only-ok t))
    (kill-whole-line arg)))

;; Count buffers in Emacs
(defun count-buffers (&optional display-anyway)
  "Display or return the number of buffers."
  (interactive)
  (let ((buf-count (length (buffer-list))))
    (if (or (interactive-p) display-anyway)
    (message "%d buffers in this Emacs" buf-count)) buf-count))

Network

(defun view-url ()
  "Open a new buffer containing the contents of URL."
  (interactive)
  (let* ((default (thing-at-point-url-at-point))
         (url (read-from-minibuffer "URL: " default)))
    (switch-to-buffer (url-retrieve-synchronously url))
    (rename-buffer url t)
    (cond ((search-forward "<?xml" nil t) (xml-mode))
          ((search-forward "<html" nil t) (html-mode)))))

Buffer-related

(defun ido-imenu ()
  "Update the imenu index and then use ido to select a symbol to navigate to.
Symbols matching the text at point are put first in the completion list."
  (interactive)
  (imenu--make-index-alist)
  (let ((name-and-pos '())
        (symbol-names '()))
    (flet ((addsymbols (symbol-list)
                       (when (listp symbol-list)
                         (dolist (symbol symbol-list)
                           (let ((name nil) (position nil))
                             (cond
                              ((and (listp symbol) (imenu--subalist-p symbol))
                               (addsymbols symbol))
                              
                              ((listp symbol)
                               (setq name (car symbol))
                               (setq position (cdr symbol)))
                              
                              ((stringp symbol)
                               (setq name symbol)
                               (setq position (get-text-property 1 'org-imenu-marker symbol))))
                             
                             (unless (or (null position) (null name))
                               (add-to-list 'symbol-names name)
                               (add-to-list 'name-and-pos (cons name position))))))))
      (addsymbols imenu--index-alist))
    ;; If there are matching symbols at point, put them at the beginning of `symbol-names'.
    (let ((symbol-at-point (thing-at-point 'symbol)))
      (when symbol-at-point
        (let* ((regexp (concat (regexp-quote symbol-at-point) "$"))
               (matching-symbols (delq nil (mapcar (lambda (symbol)
                                                     (if (string-match regexp symbol) symbol))
                                                   symbol-names))))
          (when matching-symbols
            (sort matching-symbols (lambda (a b) (> (length a) (length b))))
            (mapc (lambda (symbol) (setq symbol-names (cons symbol (delete symbol symbol-names))))
                  matching-symbols)))))
    (let* ((selected-symbol (ido-completing-read "Symbol? " symbol-names))
           (position (cdr (assoc selected-symbol name-and-pos))))
      (goto-char position))))

These belong in coding-hook:

We have a number of turn-on-* functions since it’s advised that lambda functions not go in hooks. Repeatedly evaling an add-to-list with a hook value will repeatedly add it since there’s no way to ensure that a lambda doesn’t already exist in the list.

(defun local-column-number-mode ()
  (make-local-variable 'column-number-mode)
  (column-number-mode t))

(defun local-comment-auto-fill ()
  (set (make-local-variable 'comment-auto-fill-only-comments) t)
  (auto-fill-mode t))

(defun turn-on-hl-line-mode ()
  (if window-system (hl-line-mode t)))

(defun turn-on-save-place-mode ()
  (setq save-place t))

(defun turn-on-whitespace ()
  (whitespace-mode t))
(add-hook 'coding-hook 'local-column-number-mode)
(add-hook 'coding-hook 'local-comment-auto-fill)
(add-hook 'coding-hook 'turn-on-hl-line-mode)
(add-hook 'coding-hook 'pretty-lambdas)
(defun run-coding-hook ()
  "Enable things that are convenient across all coding buffers."
  (run-hooks 'coding-hook))
(defun untabify-buffer ()
  (interactive)
  (untabify (point-min) (point-max)))
(defun indent-buffer ()
  (interactive)
  (indent-region (point-min) (point-max)))
(defun cleanup-buffer ()
  "Perform a bunch of operations on the whitespace content of a buffer."
  (interactive)
  (indent-buffer)
  (untabify-buffer)
  (delete-trailing-whitespace))
(defun recentf-ido-find-file ()
  "Find a recent file using ido."
  (interactive)
  (let ((file (ido-completing-read "Choose recent file: " recentf-list nil t)))
    (when file
      (find-file file))))

Cosmetic

(defun pretty-lambdas ()
  (font-lock-add-keywords
   nil `(("(?\\(lambda\\>\\)"
          (0 (progn (compose-region (match-beginning 1) (match-end 1)
                                    ,(make-char 'greek-iso8859-7 107))
                    nil))))))

Other

(defun eval-and-replace ()
  "Replace the preceding sexp with its value."
  (interactive)
  (backward-kill-sexp)
  (condition-case nil
      (prin1 (eval (read (current-kill 0)))
             (current-buffer))
    (error (message "Invalid expression")
           (insert (current-kill 0)))))

(defun recompile-init ()
  "Byte-compile all your dotfiles again."
  (interactive)
  (byte-recompile-directory dotfiles-dir 0)
  ;; TODO: remove elpa-to-submit once everything's submitted.
  (byte-recompile-directory (concat dotfiles-dir "elpa-to-submit/" 0)))

(defun regen-autoloads (&optional force-regen)
  "Regenerate the autoload definitions file if necessary and load it."
  (interactive "P")
  (let ((autoload-dir (concat dotfiles-dir "/elpa-to-submit"))
        (generated-autoload-file autoload-file))
    (when (or force-regen
              (not (file-exists-p autoload-file))
              (some (lambda (f) (file-newer-than-file-p f autoload-file))
                    (directory-files autoload-dir t "\\.el$")))
      (message "Updating autoloads...")
      (let (emacs-lisp-mode-hook)
        (update-directory-autoloads autoload-dir))))
  (load autoload-file))

TODO: fix this

(defun sudo-edit (&optional arg)
  (interactive "p")
  (if arg
      (find-file (concat "/sudo:root@localhost:" (ido-read-file-name "File: ")))
    (find-alternate-file (concat "/sudo:root@localhost:" buffer-file-name))))

Useful when a large block of text is required (e.g. for testing)

(defun lorem ()
  "Insert a lorem ipsum."
  (interactive)
  (insert "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do "
          "eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim"
          "ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut "
          "aliquip ex ea commodo consequat. Duis aute irure dolor in "
          "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla "
          "pariatur. Excepteur sint occaecat cupidatat non proident, sunt in "
          "culpa qui officia deserunt mollit anim id est laborum."))
(defun switch-or-start (function buffer)
  "If the buffer is current, bury it, otherwise invoke the function."
  (if (equal (buffer-name (current-buffer)) buffer)
      (bury-buffer)
    (if (get-buffer buffer)
        (switch-to-buffer buffer)
      (funcall function))))
(defun insert-date ()
  "Insert a time-stamp according to locale's date and time format."
  (interactive)
  (insert (format-time-string "%c" (current-time))))
(defun pairing-bot ()
  "If you can't pair program with a human, use this instead."
  (interactive)
  (message (if (y-or-n-p "Do you have a test for that? ") "Good." "Bad!")))

A monkeypatch to cause annotate to ignore whitespace

(defun vc-git-annotate-command (file buf &optional rev)
  (let ((name (file-relative-name file)))
    (vc-git-command buf 0 name "blame" "-w" rev)))