add new dep

2022-12-29 14:32:41 +01:00
parent a4e15965bb
commit 1e9910e471
1 changed files with 509 additions and 0 deletions
--- a/lisp/olivetti.el
+++ b/lisp/olivetti.el
@@ -0,0 +1,509 @@
+;;; olivetti.el --- Minor mode for a nice writing environment -*- lexical-binding: t; -*-
+
+;; Copyright (c) 2014-2021  Paul W. Rankin
+
+;; Author: Paul W. Rankin <pwr@bydasein.com>
+;; Keywords: wp, text
+;; Package-Version: 20220330.635
+;; Package-Commit: 8d287a80c5e3d72ac01b56c8afe60b01f18500b4
+;; Version: 2.0.4
+;; Package-Requires: ((emacs "24.4"))
+;; URL: https://github.com/rnkn/olivetti
+
+;; This file is not part of GNU Emacs.
+
+;; 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/>.
+
+;;; Commentary:
+
+;; Olivetti
+;; ========
+
+;; A simple Emacs minor mode for a nice writing environment.
+
+;; Features
+;; --------
+
+;;  - Set a desired text body width to automatically resize window margins
+;;    to keep the text comfortably in the middle of the window.
+;;  - Text body width can be the number of characters (an integer), a fraction of
+;;    the window width (a float between 0.0 and 1.0), or nil which uses the value
+;;    of fill-column +2.
+;;  - Interactively change body width with:
+;;    olivetti-shrink C-c { { { ...
+;;    olivetti-expand C-c } } } ...
+;;    olivetti-set-width C-c |
+;;  - If olivetti-body-width is an integer, the text body width will
+;;    scale with use of text-scale-mode, whereas if a fraction (float) then
+;;    the text body width will remain at that fraction.
+;;  - Change the way the text body margins look with option olivetti-style: use
+;;    margins, fringes, or both for a fancy "page" look.
+;;  - Customize olivetti-fringe face to affect only Olivetti buffers.
+;;  - Optionally remember the state of visual-line-mode on entry and
+;;    recall its state on exit.
+
+;; Olivetti keeps everything it does buffer-local, so you can write prose
+;; in one buffer and code in another, side-by-side in the same frame.
+
+
+;; Requirements
+;; ------------
+
+;;  - Emacs 24.4
+
+
+;; Installation
+;; ------------
+
+;; The latest stable release of Olivetti is available via
+;; [MELPA-stable][1]. First, add MELPA-stable to your package archives:
+
+;;     M-x customize-option RET package-archives RET
+
+;; Insert an entry named melpa-stable with URL:
+;; https://stable.melpa.org/packages/
+
+;; You can then find the latest stable version of olivetti in the
+;; list returned by:
+
+;;     M-x list-packages RET
+
+;; If you prefer the latest but perhaps unstable version, do the above
+;; using [MELPA][2].
+
+
+;; Advanced Installation
+;; ---------------------
+
+;; Download the latest tagged release, move this file into your load-path
+;; and add to your init.el file:
+
+;;     (require 'olivetti)
+
+;; If you wish to contribute to or alter Olivetti's code, clone the
+;; repository into your load-path and require as above:
+
+;;     git clone https://github.com/rnkn/olivetti.git
+
+
+;; Bugs and Feature Requests
+;; -------------------------
+
+;; Send me an email (address in the package header). For bugs, please
+;; ensure you can reproduce with:
+
+;;     $ emacs -Q -l olivetti.el
+
+
+;; Hints
+;; -----
+
+;; To always use a different width for a specific file, set a File
+;; Variable:
+
+;;     M-x add-file-local-variable RET olivetti-body-width RET 66 RET
+
+;; See (info "(emacs) File Variables")
+
+
+;; Alternatives
+;; ------------
+
+;; For those looking for a hardcore distraction-free writing mode with a much
+;; larger scope, I recommend [Writeroom Mode](https://github.com/joostkremers/writeroom-mode).
+
+
+;; [1]: https://stable.melpa.org/#/olivetti
+;; [2]: https://melpa.org/#/olivetti
+
+;;; Code:
+
+(require 'fringe)
+
+(defgroup olivetti ()
+  "Minor mode for a nice writing environment"
+  :prefix "olivetti-"
+  :group 'text)
+
+
+;;; Internal Variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(eval-when-compile
+  (require 'lisp-mnt)
+  (defconst olivetti-version
+    (lm-version load-file-name)))
+
+(defvar-local olivetti--visual-line-mode
+  nil
+  "Value of `visual-line-mode' when when `olivetti-mode' is enabled.")
+
+(defvar-local olivetti--split-window-preferred-function
+  nil
+  "Value of `split-window-preferred-function' when when
+  `olivetti-mode' is enabled.")
+
+(defvar-local olivetti--face-remap
+  nil
+  "Saved cookie from `face-remap-add-relative' when
+`olivetti-mode' is enabled.")
+
+
+;;; Options ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defcustom olivetti-mode-on-hook
+  '(visual-line-mode)
+  "Hook for `olivetti-mode', run after the mode is activated."
+  :type 'hook
+  :options '(visual-line-mode)
+  :safe 'hook)
+
+(defcustom olivetti-mode-off-hook
+  nil
+  "Hook for `olivetti-mode', run after the mode is deactivated."
+  :type 'hook
+  :safe 'hook)
+
+(defcustom olivetti-body-width
+  nil
+  "Text body width to which to adjust relative margin width.
+If an integer, set text body width to that integer in columns; if
+a floating point between 0.0 and 1.0, set text body width to that
+fraction of the total window width. If nil (the default), use the
+value of `fill-column' + 2.
+
+An integer is best if you want text body width to remain
+constant, while a floating point is best if you want text body
+width to change with window width.
+
+The floating point can anything between 0.0 and 1.0 (exclusive),
+but use a value between about 0.33 and 0.9 for best effect.
+
+This option does not affect file contents."
+  :type '(choice (const :tag "Value of fill-column + 2" nil)
+                 (integer 72)
+                 (float 0.5))
+  :safe (lambda (value)
+          (or (numberp value) (null value))))
+(make-variable-buffer-local 'olivetti-body-width)
+
+(defcustom olivetti-minimum-body-width
+  40
+  "Minimum width in columns of text body."
+  :type 'integer
+  :safe 'integerp)
+
+(defcustom olivetti-lighter
+  " Olv"
+  "Mode-line indicator for `olivetti-mode'."
+  :type '(choice (const :tag "No lighter" "") string)
+  :safe 'stringp)
+
+(defcustom olivetti-recall-visual-line-mode-entry-state
+  t
+  "Recall the state of `visual-line-mode' upon exiting.
+When non-nil, remember if `visual-line-mode' was enabled or not
+upon activating `olivetti-mode' and restore that state upon
+exiting."
+  :type 'boolean
+  :safe 'booleanp)
+
+(defcustom olivetti-style
+  nil
+  "Window elements used to balance the text body.
+Valid options are:
+
+    nil         use margins (default)
+    t           use fringes
+    fancy       use both margins with fringes outside
+
+n.b. Fringes are only available on a graphical window system and
+will fall back to margins on console."
+  :type '(choice (const :tag "Margins" nil)
+                 (const :tag "Fringes" t)
+                 (const :tag "Fringes and Margins" fancy))
+  :set (lambda (symbol value)
+         (set-default symbol value)
+         (when (featurep 'olivetti)
+           (olivetti-reset-all-windows))))
+
+(defcustom olivetti-margin-width
+  10
+  "Width in columns of margin between text body and fringes.
+Only has any effect when `olivetti-style' is set to 'fancy."
+  :type '(choice (const :tag "None" nil)
+                 (integer :tag "Columns" 10))
+  :safe 'integerp
+  :set (lambda (symbol value)
+         (set-default symbol value)
+         (when (featurep 'olivetti)
+           (olivetti-reset-all-windows))))
+
+(defface olivetti-fringe
+  '((t (:inherit fringe)))
+  "Face for the fringes when `olivetti-style' is non-nil."
+  :group 'olivetti)
+
+
+;;; Set Windows ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun olivetti-scale-width (width)
+  "Scale WIDTH in accordance with the face height.
+For compatibility with `text-scale-mode', if
+`face-remapping-alist' includes a :height property on the default
+face, scale WIDTH by that factor if it is a fraction, by (height/100)
+if it is an integer, and otherwise return WIDTH."
+  (let ((height (plist-get (cadr (assq 'default face-remapping-alist)) :height)))
+    (when (integerp height)
+      (setq height (/ height 100.0)))
+    (round (* width (or height 1)))))
+
+(defun olivetti-normalize-width (width window)
+  "Parse WIDTH to a safe pixel value for `olivetti-body-width' for WINDOW."
+  (let ((char-width (frame-char-width (window-frame window)))
+        (window-width-pix (window-body-width window t))
+        min-width-pix)
+    (setq min-width-pix (* char-width
+                           (+ olivetti-minimum-body-width
+                              (% olivetti-minimum-body-width 2))))
+    (olivetti-scale-width
+     (if (floatp width)
+         (floor (max min-width-pix (* window-width-pix (min width 1.0))))
+       (max min-width-pix (min (* width char-width) window-width-pix))))))
+
+(defun olivetti-reset-window (window)
+  "Remove Olivetti's parameters and margins from WINDOW."
+  (when (eq (window-parameter window 'split-window) 'olivetti-split-window)
+    (set-window-parameter window 'split-window nil))
+  (if (consp fringe-mode)
+      (set-window-fringes window (car fringe-mode) (cdr fringe-mode))
+    (set-window-fringes window fringe-mode fringe-mode))
+  (set-window-margins window nil))
+
+(defun olivetti-reset-all-windows ()
+  "Call `olivetti-reset-window' on all windows."
+  (walk-windows #'olivetti-reset-window nil t))
+
+;; FIXME: these split-window functions seem to be ignored by
+;; `window-toggle-side-windows'
+;; WORKAROUND:
+;; (with-eval-after-load 'olivetti
+;;   (advice-add 'window-toggle-side-windows
+;;               :before 'olivetti-reset-all-windows))
+
+(defun olivetti-split-window (&optional window size side pixelwise)
+  "Call `split-window' after resetting WINDOW.
+Pass SIZE, SIDE and PIXELWISE unchanged."
+  (olivetti-reset-all-windows)
+  (split-window window size side pixelwise))
+
+(defun olivetti-split-window-sensibly (&optional window)
+  "Like `olivetti-split-window' but call `split-window-sensibly'.
+Pass WINDOW unchanged."
+  (olivetti-reset-all-windows)
+  (funcall olivetti--split-window-preferred-function window))
+
+(defun olivetti-set-window (window-or-frame)
+  "Balance window margins displaying current buffer.
+If WINDOW-OR-FRAME is a frame, cycle through windows displaying
+current buffer in that frame, otherwise only work on the selected
+window."
+  (if (framep window-or-frame)
+      (mapc #'olivetti-set-window
+            (get-buffer-window-list nil nil window-or-frame))
+    ;; WINDOW-OR-FRAME passed below *must* be a window
+    (with-selected-window window-or-frame
+      (olivetti-reset-window window-or-frame)
+      (when olivetti-mode
+        ;; If `olivetti-body-width' is nil, we need to calculate from
+        ;; `fill-column'
+        (when (null olivetti-body-width)
+          (setq olivetti-body-width (+ fill-column 2)))
+        (let ((char-width-pix   (frame-char-width (window-frame window-or-frame)))
+              (window-width-pix (window-body-width window-or-frame t))
+              (safe-width-pix   (olivetti-normalize-width
+                                 olivetti-body-width window-or-frame)))
+          ;; Handle possible display of fringes
+          (when (and window-system olivetti-style)
+            (let ((fringe-total (- (window-pixel-width window-or-frame)
+                                   safe-width-pix))
+                  fringe)
+              ;; Account for fancy display
+              (when (eq olivetti-style 'fancy)
+                (setq fringe-total
+                      (- fringe-total
+                         (* olivetti-margin-width char-width-pix 2))))
+              ;; Calculate a single fringe width
+              (setq fringe (max (round (/ fringe-total 2.0)) 0))
+              ;; Set the fringes
+              (set-window-fringes window-or-frame fringe fringe t)))
+          ;; Calculate margins widths as body pixel width less fringes
+          (let ((fringes (window-fringes window-or-frame))
+                (margin-total-pix (/ (- window-width-pix safe-width-pix) 2.0))
+                left-margin right-margin)
+            ;; Convert to character cell columns
+            (setq left-margin  (max (round (/ (- margin-total-pix
+                                                 (car fringes))
+                                              char-width-pix))
+                                    0)
+                  right-margin (max (round (/ (- margin-total-pix
+                                                 (cadr fringes))
+                                              char-width-pix))
+                                    0))
+            ;; Finally set the margins
+            (set-window-margins window-or-frame left-margin right-margin)))
+        ;; Set remaining window parameters
+        (set-window-parameter window-or-frame 'split-window
+                              'olivetti-split-window)))))
+
+(defun olivetti-set-buffer-windows ()
+  "Balance window margins in all windows displaying current buffer.
+Cycle through all windows in all visible frames displaying the
+current buffer, and call `olivetti-set-window'."
+  (mapc #'olivetti-set-window (get-buffer-window-list nil nil 'visible)))
+
+
+;;; Width Interaction ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun olivetti-set-width (width)
+  "Set text body width to WIDTH with relative margins.
+WIDTH may be an integer specifying columns or a float specifying
+a fraction of the window width."
+  (interactive
+   (list (if current-prefix-arg
+             (prefix-numeric-value current-prefix-arg)
+           (read-number "Set text body width (integer or float): "
+                        olivetti-body-width))))
+  (setq olivetti-body-width width)
+  (olivetti-set-buffer-windows)
+  (message "Text body width set to %s" olivetti-body-width))
+
+(defun olivetti-expand (&optional arg)
+  "Incrementally increase the value of `olivetti-body-width'.
+If prefixed with ARG, incrementally decrease."
+  (interactive "P")
+  (let* ((p (if arg -1 1))
+         (n (cond ((integerp olivetti-body-width)
+                   (+ olivetti-body-width (* 2 p)))
+                  ((floatp olivetti-body-width)
+                   (+ olivetti-body-width (* 0.01 p))))))
+    (setq olivetti-body-width n))
+  (olivetti-set-buffer-windows)
+  (message "Text body width set to %s" olivetti-body-width)
+  (unless overriding-terminal-local-map
+    (let ((prefix-keys (substring (this-single-command-keys) 0 -1))
+          (map (cdr olivetti-mode-map)))
+      (when (< 0 (length prefix-keys))
+        (mapc (lambda (k) (setq map (assq k map))) prefix-keys)
+        (setq map (cdr-safe map))
+        (when (keymapp map) (set-transient-map map t))))))
+
+(defun olivetti-shrink (&optional arg)
+  "Incrementally decrease the value of `olivetti-body-width'.
+If prefixed with ARG, incrementally increase."
+  (interactive "P")
+  (let ((p (unless arg t)))
+    (olivetti-expand p)))
+
+
+;;; Keymap ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar olivetti-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "C-c }") #'olivetti-expand)
+    (define-key map (kbd "C-c {") #'olivetti-shrink)
+    (define-key map (kbd "C-c |") #'olivetti-set-width)
+    (define-key map (kbd "C-c \\") #'olivetti-set-width) ;; OBSOLETE
+    (define-key map [left-margin mouse-1] #'mouse-set-point)
+    (define-key map [right-margin mouse-1] #'mouse-set-point)
+    (define-key map [left-fringe mouse-1] #'mouse-set-point)
+    (define-key map [right-fringe mouse-1] #'mouse-set-point)
+    ;; This code is taken from https://github.com/joostkremers/visual-fill-column
+    (when (bound-and-true-p mouse-wheel-mode)
+      (define-key map (vector 'left-margin mouse-wheel-down-event) 'mwheel-scroll)
+      (define-key map (vector 'left-margin mouse-wheel-up-event) 'mwheel-scroll)
+      (define-key map (vector 'right-margin mouse-wheel-down-event) 'mwheel-scroll)
+      (define-key map (vector 'right-margin mouse-wheel-up-event) 'mwheel-scroll))
+    map)
+  "Mode map for `olivetti-mode'.")
+
+
+;;; Mode Definition ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;###autoload
+(define-minor-mode olivetti-mode
+  "Olivetti provides a nice writing environment.
+Window margins are set to relative widths to accomodate a text
+body width set with `olivetti-body-width'."
+  :init-value nil
+  :lighter olivetti-lighter
+  (if olivetti-mode
+      (progn
+        (cond ((<= emacs-major-version 24)
+               (add-hook 'window-configuration-change-hook
+                         #'olivetti-set-buffer-windows t t))
+              ((<= emacs-major-version 26)
+               (add-hook 'window-configuration-change-hook
+                         #'olivetti-set-buffer-windows t t)
+               (add-hook 'window-size-change-functions
+                         #'olivetti-set-window t t))
+              ((<= 27 emacs-major-version)
+               (add-hook 'window-size-change-functions
+                         #'olivetti-set-window t t)))
+        (add-hook 'change-major-mode-hook
+                  #'olivetti-reset-all-windows nil t)
+        (add-hook 'text-scale-mode-hook
+                  #'olivetti-set-buffer-windows t t)
+        (unless (bound-and-true-p olivetti--visual-line-mode)
+          (setq olivetti--visual-line-mode
+                visual-line-mode))
+        (unless (bound-and-true-p olivetti--split-window-preferred-function)
+          (setq olivetti--split-window-preferred-function
+                split-window-preferred-function))
+        (setq-local split-window-preferred-function
+                    #'olivetti-split-window-sensibly)
+        (setq olivetti--face-remap
+              (face-remap-add-relative 'fringe 'olivetti-fringe))
+        (olivetti-set-buffer-windows))
+    (remove-hook 'window-configuration-change-hook
+                 #'olivetti-set-buffer-windows t)
+    (remove-hook 'window-size-change-functions
+                 #'olivetti-set-window t)
+    (remove-hook 'text-scale-mode-hook
+                 #'olivetti-set-window t)
+    (olivetti-set-buffer-windows)
+    (when olivetti--face-remap
+      (face-remap-remove-relative olivetti--face-remap))
+    (when olivetti-recall-visual-line-mode-entry-state
+      (if olivetti--visual-line-mode
+          (when (not visual-line-mode) (visual-line-mode 1))
+        (when visual-line-mode (visual-line-mode 0))))
+    (mapc #'kill-local-variable '(split-window-preferred-function
+                                  olivetti-body-width
+                                  olivetti--visual-line-mode
+                                  olivetti--face-remap
+                                  olivetti--split-window-preferred-function))))
+
+
+
+(provide 'olivetti)
+
+;;; olivetti.el ends here
+
+;; Local Variables:
+;; coding: utf-8
+;; fill-column: 80
+;; require-final-newline: t
+;; sentence-end-double-space: nil
+;; indent-tabs-mode: nil
+;; End: