Too lazy for a commit message. Sue me!

core/core-editor.el

@@ -16,6 +16,9 @@
  scroll-conservatively   1001
  scroll-preserve-screen-position t
 
+ hscroll-step 5
+ hscroll-margin 6
+
  shift-select-mode       nil
  tabify-regexp "^\t* [ \t]+"
  whitespace-style '(face tabs tab-mark newline newline-mark)

core/core-evil.el

@@ -230,16 +230,16 @@
                               (?\] "[]})]")
                               (?\; "[;:]")))
 
-  (define-key evil-normal-state-map (kbd "s") nil)
-  (define-key evil-normal-state-map (kbd "S") nil)
-  (define-key evil-motion-state-map (kbd "s") 'evil-snipe-s)
-  (define-key evil-motion-state-map (kbd "S") 'evil-snipe-S)
-  (define-key evil-motion-state-map (kbd "f") 'evil-snipe-f)
-  (define-key evil-motion-state-map (kbd "F") 'evil-snipe-F)
-  (define-key evil-motion-state-map (kbd "t") 'evil-snipe-t)
-  (define-key evil-motion-state-map (kbd "T") 'evil-snipe-T)
-  (define-key evil-operator-state-map (kbd "z") 'evil-snipe-s)
-  (define-key evil-operator-state-map (kbd "Z") 'evil-snipe-S)
+  (define-key evil-normal-state-map "s" nil)
+  (define-key evil-normal-state-map "S" nil)
+  (define-key evil-motion-state-map "s" 'evil-snipe-s)
+  (define-key evil-motion-state-map "S" 'evil-snipe-S)
+  (define-key evil-motion-state-map "f" 'evil-snipe-f)
+  (define-key evil-motion-state-map "F" 'evil-snipe-F)
+  (define-key evil-motion-state-map "t" 'evil-snipe-t)
+  (define-key evil-motion-state-map "T" 'evil-snipe-T)
+  (define-key evil-operator-state-map "z" 'evil-snipe-s)
+  (define-key evil-operator-state-map "Z" 'evil-snipe-S)
   :config
   (evil-snipe-mode 1)
   (evil-snipe-override-mode 1))
@@ -251,6 +251,19 @@
              evil-surround-region)
   :config
   (global-evil-surround-mode 1)
+
+  (add-hook! org-mode
+    (mapc (lambda (p) (add-to-list 'evil-surround-pairs-alist p))
+          '((?l . narf/evil-surround-latex))))
+
+  (add-hook! emacs-lisp-mode
+    (setq evil-surround-pairs-alist
+          (cons '(?\` . ("`" . "*")) evil-surround-pairs-alist)))
+
+  (add-hook! python-mode
+    (setq evil-surround-pairs-alist
+          (cons '(?d . ("\"\"\"" . "\"\"\"")) evil-surround-pairs-alist)))
+
   ;; Escaped surround characters
   (setq-default evil-surround-pairs-alist
                 (cons '(?\\ . narf/evil-surround-escaped)

core/core-os-osx.el

@@ -9,9 +9,11 @@
       mac-option-modifier  'alt
 
       ;; sane trackpad/mouse scroll settings
+      mac-redisplay-dont-reset-vscroll t
       mac-mouse-wheel-smooth-scroll nil
       mouse-wheel-scroll-amount '(8 ((shift) . 2))  ;; one line at a time
-      mouse-wheel-progressive-speed nil               ;; don't accelerate scrolling
+      mouse-wheel-progressive-speed nil             ;; don't accelerate scrolling
+
 
       ;;; NOTE These mean nothing to railwaycat's emacs-mac build on OSX
       ;; Curse Lion and its sudden but inevitable fullscreen mode!
@@ -42,8 +44,8 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(after! evil
-  (when (featurep 'ns)
+(when (featurep 'ns)
+  (after! evil
     ;; On OSX, stop copying each visual state move to the clipboard:
     ;; https://bitbucket.org/lyro/evil/issue/336/osx-visual-state-copies-the-region-on
     ;; Most of this code grokked from:

core/lib/defuns-evil.el

@@ -17,13 +17,13 @@
     (hs-minor-mode 1))
   (if count (hs-hide-level count) (evil-close-folds)))
 
-;;;###autoload (autoload 'narf-multi-next-line "defuns-evil" nil t)
-(evil-define-motion narf-multi-next-line (count)
+;;;###autoload (autoload 'narf/multi-next-line "defuns-evil" nil t)
+(evil-define-motion narf/multi-next-line (count)
   "Move down 6 lines"
   :type line (evil-line-move 6))
 
-;;;###autoload (autoload 'narf-multi-previous-line "defuns-evil" nil t)
-(evil-define-motion narf-multi-previous-line (count)
+;;;###autoload (autoload 'narf/multi-previous-line "defuns-evil" nil t)
+(evil-define-motion narf/multi-previous-line (count)
   "Move up 6 lines"
   :type line (evil-line-move -6))
 
@@ -52,15 +52,21 @@
 ;;;###autoload
 (defun narf/evil-surround-escaped ()
   "Escaped surround characters."
-    (let* ((char (string (read-char "\\")))
-           (pair (cond ((string-match "[]})[{(]" char)
-                        (let ((-pair (cdr (assoc (string-to-char char) evil-surround-pairs-alist))))
-                          `(,(car -pair) . ,(cdr -pair))))
-                       (t
-                        `(,char . ,char))))
-           (format (if (sp-point-in-string) "\\\\%s" "\\%s")))
-      (cons (format format (car pair))
-            (format format (cdr pair)))))
+  (let* ((char (string (read-char "\\")))
+         (pair (cond ((string-match-p "[]})[{(]" char)
+                      (let ((-pair (cdr (assoc (string-to-char char) evil-surround-pairs-alist))))
+                        `(,(car -pair) . ,(cdr -pair))))
+                     (t
+                      `(,char . ,char))))
+         (format (if (sp-point-in-string) "\\\\%s" "\\%s")))
+    (cons (format format (car pair))
+          (format format (cdr pair)))))
+
+;;;###autoload
+(defun narf/evil-surround-latex ()
+  "LaTeX commands"
+  (let* ((command (read-string "\\")))
+    (cons (format "\\%s{" command) "}")))
 
 ;;;###autoload (autoload 'narf/evil-macro-on-all-lines "defuns-evil" nil t)
 (evil-define-operator narf/evil-macro-on-all-lines (beg end &optional arg)
@@ -75,5 +81,17 @@
         (single-key-description
           (read-char "What macro?"))))))
 
+;;;###autoload
+(defun narf/evil-window-split ()
+  (interactive)
+  (call-interactively 'evil-window-split)
+  (evil-window-down 1))
+
+;;;###autoload
+(defun narf/evil-window-vsplit ()
+  (interactive)
+  (call-interactively 'evil-window-vsplit)
+  (evil-window-right 1))
+
 (provide 'defuns-evil)
 ;;; defuns-evil.el ends here

core/lib/defuns-ui.el

@@ -15,8 +15,38 @@
   (interactive "<!>")
   (if bang
       (writeroom-mode (if writeroom-mode -1 1))
-    (set-frame-parameter nil 'fullscreen
-                         (when (not (frame-parameter nil 'fullscreen)) 'fullboth))))
+    (set-frame-parameter nil 'fullscreen (if (not (frame-parameter nil 'fullscreen)) 'fullboth))))
+
+;;;###autoload
+(defvar narf--write-mode nil)
+(defun narf:toggle-write-mode ()
+  (interactive)
+  (require 'writeroom-mode)
+  (let ((writeroom-width 100)
+        (writeroom-extra-line-spacing 12))
+    (writeroom-mode (if writeroom-mode -1 1))
+    (setq narf--write-mode writeroom-mode)
+
+    ;; (setq truncate-lines (not narf--write-mode))
+    ;; (setq word-wrap narf--write-mode)
+    (variable-pitch-mode narf--write-mode)
+
+    (if narf--write-mode
+        (narf/load-theme 'solarized-light)
+      (narf/reset-theme))
+
+    (fringe-mode (if narf--write-mode 0 '(3 . 6)))
+    (auto-fill-mode (if narf--write-mode -1 +1))
+    (text-scale-set (if narf--write-mode 2.5 0))
+    (scroll-bar-mode (if narf--write-mode 1 -1))
+
+    (when IS-MAC
+      (setq ;; sane trackpad/mouse scroll settings
+       mac-mouse-wheel-smooth-scroll narf--write-mode
+       mouse-wheel-progressive-speed narf--write-mode))
+
+    (when (eq major-mode 'org-mode)
+      (org-indent-mode (if narf--write-mode -1 1)))))
 
 (defvar narf--big-mode nil)
 ;;;###autoload
@@ -28,7 +58,15 @@
 ;;;###autoload
 (defun narf/reset-theme ()
   (interactive)
-  (load-theme (if window-system narf-theme narf-term-theme) t))
+  (narf/load-theme 'narf-dark))
+
+;;;###autoload
+(defun narf/load-theme (theme)
+  (interactive)
+  (mapc (lambda (th)
+          (when (custom-theme-enabled-p th) (disable-theme th)))
+        custom-enabled-themes)
+  (load-theme theme t))
 
 ;;;###autoload
 (defun narf/default-font ()
@@ -40,5 +78,14 @@
   (interactive)
   (set-frame-font narf-big-font))
 
+;;;###autoload
+(defun narf/show-as (how &optional pred)
+  (let* ((beg (match-beginning 1))
+         (end (match-end 1))
+         (ok (or (not pred) (funcall pred beg end))))
+    (when ok
+      (compose-region beg end how 'decompose-region))
+    nil))
+
 (provide 'defuns-ui)
 ;;; defuns-ui.el ends here

core/lib/macros-auto-insert.el

@@ -3,7 +3,9 @@
 
 ;;;###autoload
 (defmacro add-template! (regexp-or-major-mode uuid yas-mode &optional project-only)
-  `(define-auto-insert ,regexp-or-major-mode
+  `(define-auto-insert ,(if (stringp regexp-or-major-mode)
+                            regexp-or-major-mode
+                          (eval regexp-or-major-mode))
      (lambda ()
        (unless (or (and ,project-only (not (narf/project-p)))
                    (not (or (eq major-mode ,yas-mode)