changing repositories

1 files changed, 3495 insertions, 0 deletions

diff --git a/custom/eplot.el b/custom/eplot.el
new file mode 100644
index 00000000..c00a3e31
--- /dev/null
+++ b/custom/eplot.el
@@ -0,0 +1,3495 @@
+;;; eplot.el --- Manage and Edit Wordpress Posts -*- lexical-binding: t -*-
+
+;; Copyright (C) 2024 Free Software Foundation, Inc.
+
+;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
+;; Keywords: charts
+;; Package: eplot
+;; Version: 1.0
+;; Package-Requires: ((emacs "29.0.59") (pcsv "0.0"))
+
+;; eplot 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 2, or (at your option)
+;; any later version.
+
+;;; Commentary:
+
+;; The main entry point is `M-x eplot' in a buffer with time series
+;; data.
+;;
+;; If installing manually, put something like the following in your
+;; Emacs init file (but adjust the path to where you've put eplot):
+;; 
+;; (push "~/src/eplot/" load-path)
+;; (autoload 'eplot "eplot" nil t)
+;; (autoload 'eplot-mode "eplot" nil t)
+;; (unless (assoc "\\.plt" auto-mode-alist)
+;;   (setq auto-mode-alist (cons '("\\.plt" . eplot-mode) auto-mode-alist)))
+
+;; This requires the pcsv package to parse CSV files.
+
+;;; Code:
+
+(require 'svg)
+(require 'cl-lib)
+(require 'face-remap)
+(require 'eieio)
+(require 'iso8601)
+(require 'transient)
+
+(defvar eplot--user-defaults nil)
+(defvar eplot--chart-headers nil)
+(defvar eplot--plot-headers nil)
+(defvar eplot--transient-settings nil)
+
+
+(defvar eplot--colors
+  '("aliceblue" "antiquewhite" "aqua" "aquamarine" "azure" "beige" "bisque"
+    "black" "blanchedalmond" "blue" "blueviolet" "brown" "burlywood"
+    "cadetblue" "chartreuse" "chocolate" "coral" "cornflowerblue" "cornsilk"
+    "crimson" "cyan" "darkblue" "darkcyan" "darkgoldenrod" "darkgray"
+    "darkgreen" "darkgrey" "darkkhaki" "darkmagenta" "darkolivegreen"
+    "darkorange" "darkorchid" "darkred" "darksalmon" "darkseagreen"
+    "darkslateblue" "darkslategray" "darkslategrey" "darkturquoise"
+    "darkviolet" "deeppink" "deepskyblue" "dimgray" "dimgrey" "dodgerblue"
+    "firebrick" "floralwhite" "forestgreen" "fuchsia" "gainsboro" "ghostwhite"
+    "gold" "goldenrod" "gray" "green" "greenyellow" "grey" "honeydew" "hotpink"
+    "indianred" "indigo" "ivory" "khaki" "lavender" "lavenderblush" "lawngreen"
+    "lemonchiffon" "lightblue" "lightcoral" "lightcyan" "lightgoldenrodyellow"
+    "lightgray" "lightgreen" "lightgrey" "lightpink" "lightsalmon"
+    "lightseagreen" "lightskyblue" "lightslategray" "lightslategrey"
+    "lightsteelblue" "lightyellow" "lime" "limegreen" "linen" "magenta"
+    "maroon" "mediumaquamarine" "mediumblue" "mediumorchid" "mediumpurple"
+    "mediumseagreen" "mediumslateblue" "mediumspringgreen" "mediumturquoise"
+    "mediumvioletred" "midnightblue" "mintcream" "mistyrose" "moccasin"
+    "navajowhite" "navy" "oldlace" "olive" "olivedrab" "orange" "orangered"
+    "orchid" "palegoldenrod" "palegreen" "paleturquoise" "palevioletred"
+    "papayawhip" "peachpuff" "peru" "pink" "plum" "powderblue" "purple" "red"
+    "rosybrown" "royalblue" "saddlebrown" "salmon" "sandybrown" "seagreen"
+    "seashell" "sienna" "silver" "skyblue" "slateblue" "slategray" "slategrey"
+    "snow" "springgreen" "steelblue" "tan" "teal" "thistle" "tomato"
+    "turquoise" "violet" "wheat" "white" "whitesmoke" "yellow" "yellowgreen"))
+
+(defun eplot-set (header value)
+  "Set the default value of HEADER to VALUE.
+To get a list of all possible HEADERs, use the `M-x
+eplot-list-chart-headers' command.
+
+Also see `eplot-reset'."
+  (let ((elem (or (assq header eplot--chart-headers)
+		  (assq header eplot--plot-headers))))
+    (unless elem
+      (error "No such header type: %s" header))
+    (eplot--add-default header value)))
+
+(defun eplot--add-default (header value)
+  ;; We want to preserve the order defaults have been added, so that
+  ;; we can apply them in the same order.  This makes a difference
+  ;; when we're dealing with specs that have inheritence.
+  (setq eplot--user-defaults (delq (assq header eplot--user-defaults)
+				   eplot--user-defaults))
+  (setq eplot--user-defaults (list (cons header value))))
+
+(defun eplot-reset (&optional header)
+  "Reset HEADER to defaults.
+If HEADER is nil or not present, reset everything to defaults."
+  (if header
+      (setq eplot--user-defaults (delq (assq header eplot--user-defaults)
+				       eplot--user-defaults))
+    (setq eplot--user-defaults nil)))
+
+(unless (assoc "\\.plt" auto-mode-alist)
+  (setq auto-mode-alist (cons '("\\.plt" . eplot-mode) auto-mode-alist)))
+
+;;; eplot modes.
+
+(defvar-keymap eplot-mode-map
+  "C-c C-c" #'eplot-update-view-buffer
+  "C-c C-p" #'eplot-switch-view-buffer
+  "C-c C-e" #'eplot-list-chart-headers
+  "C-c C-v" #'eplot-customize
+  "C-c C-l" #'eplot-create-controls
+  "TAB" #'eplot-complete)
+
+;; # is working overtime in the syntax here:
+;;  It can be a color like Color: #e0e0e0, and
+;;  it can be a setting like 33 # Label: Apples,
+;;  when it starts a line it's a comment.
+(defvar eplot-font-lock-keywords
+  `(("^[ \t\n]*#.*" . font-lock-comment-face)
+    ("^[^ :\n]+:" . font-lock-keyword-face)
+    ("#[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\\([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\\)?" . font-lock-variable-name-face)
+    ("#.*" . font-lock-builtin-face)))
+
+(define-derived-mode eplot-mode text-mode "eplot"
+  "Major mode for editing charts.
+Use the \\[eplot-list-chart-headers] command to get a list of all
+possible chart headers."
+  (setq-local completion-at-point-functions
+	      (cons 'eplot--complete-header completion-at-point-functions))
+  (setq-local font-lock-defaults
+	      '(eplot-font-lock-keywords nil nil nil)))
+
+(defun eplot-complete ()
+  "Complete headers."
+  (interactive)
+  (cond
+   ((let ((completion-fail-discreetly t))
+      (completion-at-point))
+    ;; Completion was performed; nothing else to do.
+    nil)
+   (t (indent-relative))))
+
+(defun eplot--complete-header ()
+  (or
+   ;; Complete headers names.
+   (and (or (looking-at ".*:")
+	    (and (looking-at "[ \t]*$")
+		 (save-excursion
+		   (beginning-of-line)
+		   (not (looking-at "\\(.+\\):")))))
+	(lambda ()
+	  (let ((headers (mapcar
+			  (lambda (h)
+			    (if (looking-at ".*:")
+				(capitalize (symbol-name (car h)))
+			      (concat (capitalize (symbol-name (car h))) ": ")))
+			  (save-excursion
+			    ;; If we're after the headers, then we want
+			    ;; to complete over the plot headers.  Otherwise,
+			    ;; complete over the chart headers.
+			    (if (and (not (bobp))
+				     (progn
+				       (forward-line -1)
+				       (re-search-backward "^[ \t]*$" nil t)))
+				eplot--plot-headers
+			      eplot--chart-headers))))
+		(completion-ignore-case t))
+	    (completion-in-region (pos-bol) (line-end-position) headers)
+	    'completion-attempted)))
+   ;; Complete header values.
+   (let ((hname nil))
+     (and (save-excursion
+	    (and (looking-at "[ \t]*$")
+		 (progn
+		   (beginning-of-line)
+		   (and (looking-at "\\(.+\\):")
+			(setq hname (intern (downcase (match-string 1)))))))
+	    (lambda ()
+	      (let ((valid (plist-get
+			    (cdr (assq hname (append eplot--plot-headers
+						     eplot--chart-headers)))
+			    :valid))
+		    (completion-ignore-case t))
+		(completion-in-region
+		 (save-excursion
+		   (search-backward ":" (pos-bol) t)
+		   (skip-chars-forward ": \t")
+		   (point))
+		 (line-end-position)
+		 (mapcar #'symbol-name valid))
+		'completion-attempted)))))))
+
+(define-minor-mode eplot-minor-mode
+  "Minor mode to issue commands from an eplot data buffer."
+  :lighter " eplot")
+
+(defvar-keymap eplot-minor-mode-map
+  "H-l" #'eplot-eval-and-update)
+
+(defvar-keymap eplot-view-mode-map
+  "s" #'eplot-view-write-file
+  "w" #'eplot-view-write-scaled-file
+  "c" #'eplot-view-customize
+  "l" #'eplot-create-controls)
+
+(define-derived-mode eplot-view-mode special-mode "eplot view"
+  "Major mode for displaying eplots."
+  (setq-local revert-buffer-function #'eplot-update
+	      cursor-type nil))
+
+(defun eplot-view-write-file (file &optional width)
+  "Write the current chart to a file.
+If you type in a file name that ends with something else than \"svg\",
+ImageMagick \"convert\" will be used to convert the image first.
+
+If writing to a PNG file, \"rsvg-conver\" will be used instead if
+it exists as this usually gives better results."
+  (interactive "FWrite to file name: ")
+  (when (and (file-exists-p file)
+	     (not (yes-or-no-p "File exists, overwrite? ")))
+    (error "Not overwriting the file"))
+  (save-excursion
+    (goto-char (point-min))
+    (let ((match
+	   (text-property-search-forward 'display nil
+					 (lambda (_ e)
+					   (and (consp e)
+						(eq (car e) 'image))))))
+      (unless match
+	(error "Can't find an image in the current buffer"))
+      (let ((svg (plist-get (cdr (prop-match-value match)) :data))
+	    (tmp " *eplot convert*")
+	    (executable (if width "rsvg-convert" "convert"))
+	    sfile ofile)
+	(unless svg
+	  (error "Invalid image in the current buffer"))
+	(with-temp-buffer
+	  (set-buffer-multibyte nil)
+	  (svg-print svg)
+	  (if (string-match-p "\\.svg\\'" file)
+	      (write-region (point-min) (point-max) file)
+	    (if (and (string-match-p "\\.png\\'" file)
+		     (executable-find "rsvg-convert"))
+		(setq executable "rsvg-convert")
+	      (unless (executable-find executable)
+		(error "%s isn't installed; can only save svg files"
+		       executable)))
+	    (when (and (equal executable "rsvg-convert")
+		       (not (string-match-p "\\.png\\'" file))
+		       (not (executable-find "convert")))
+	      (error "Can only write PNG files when scaling because \"convert\" isn't installed"))
+	    (unwind-protect
+		(progn
+		  (setq sfile (make-temp-file "eplot" nil ".svg")
+			ofile (make-temp-file "eplot" nil ".png"))
+		  (write-region (point-min) (point-max) sfile nil 'silent)
+		  ;; We don't use `call-process-region', because
+		  ;; convert doesn't seem to like that?
+		  (let ((code (if (equal executable "rsvg-convert")
+				  (apply
+				   #'call-process
+				   executable nil (get-buffer-create tmp) nil
+				   `(,(format "--output=%s"
+					      (expand-file-name ofile))
+				     ,@(and width
+					    `(,(format "--width=%d" width)
+					      "--keep-aspect-ratio"))
+				     ,sfile))
+				(call-process
+				 executable nil (get-buffer-create tmp) nil
+				 sfile file))))
+		    (eplot--view-error code tmp)
+		    (when (file-exists-p ofile)
+		      (if (string-match-p "\\.png\\'" file)
+			  (rename-file ofile file)
+			(let ((code (call-process "convert" nil tmp nil
+						  ofile file)))
+			  (eplot--view-error code tmp))))
+		    (message "Wrote %s" file)))
+	      ;; Clean-up.
+	      (when (get-buffer tmp)
+		(kill-buffer tmp))
+	      (when (file-exists-p sfile)
+		(delete-file sfile))
+	      (when (file-exists-p ofile)
+		(delete-file sfile)))))))))
+
+(defun eplot--view-error (code tmp)
+  (unless (zerop code)
+    (error "Error code %d: %s"
+	   code
+	   (with-current-buffer tmp
+	     (while (search-forward "[ \t\n]+" nil t)
+	       (replace-match " "))
+	     (string-trim (buffer-string))))))
+
+(defun eplot-view-write-scaled-file (width file)
+  "Write the current chart to a rescaled to a file.
+The rescaling is done by \"rsvg-convert\", which has to be
+installed.  Rescaling is done when rendering, so this should give
+you a clear, non-blurry version of the chart at any size."
+  (interactive "nWidth: \nFWrite to file: ")
+  (eplot-view-write-file file width))
+
+(defun eplot-view-customize ()
+  "Customize the settings for the chart in the current buffer."
+  (interactive)
+  (with-suppressed-warnings ((interactive-only eplot-customize))
+    (eplot-customize)))
+
+(defvar eplot--data-buffer nil)
+(defvar eplot--current-chart nil)
+
+(defun eplot ()
+  "Plot the data in the current buffer."
+  (interactive)
+  (eplot-update-view-buffer))
+
+(defun eplot-with-headers (header-file)
+  "Plot the data in the current buffer using headers from a file."
+  (interactive "fHeader file: ")
+  (eplot-update-view-buffer
+   (with-temp-buffer
+     (insert-file-contents header-file)
+     (eplot--parse-headers))))
+
+(defun eplot-make-plot (headers &rest datas)
+  "Return an SVG based on DATA.
+DATA should be pairs of headers, then followed by the plot data."
+  (with-temp-buffer
+    ;; Insert the headers.
+    (dolist (line headers)
+      (insert (format "%s:" (pop line)))
+      (dolist (elem line)
+	(insert (format " %s" elem)))
+      (insert "\n"))
+    ;; Then insert all the plot data sets.
+    (dolist (data datas)
+      (insert "\n")
+      (dolist (line data)
+	(dolist (elem line)
+	  (insert (format "%s" elem) " "))
+	(insert "\n")))
+    ;;(setq a (buffer-string)) (debug)
+    (eplot--render (eplot--parse-buffer) t)))
+
+(defun eplot-switch-view-buffer ()
+  "Switch to the eplot view buffer and render the chart."
+  (interactive)
+  (eplot-update-view-buffer nil t))
+
+(defun eplot-update-view-buffer (&optional headers switch)
+  "Update the eplot view buffer based on the current data buffer."
+  (interactive)
+  ;; This is mainly useful during implementation.
+  (if (and (eq major-mode 'emacs-lisp-mode)
+	   (get-buffer-window "*eplot*" t))
+      (with-current-buffer "*eplot*"
+	(eplot-update)
+	(when-let ((win (get-buffer-window "*eplot*" t)))
+	  (set-window-point win (point-min))))
+    ;; Normal case.
+    (let* ((eplot--user-defaults (eplot--settings-table))
+	   (data (eplot--parse-buffer))
+	   (data-buffer (current-buffer))
+	   (window (selected-window)))
+      (unless data
+	(user-error "No data in the current buffer"))
+      (setq data (eplot--inject-headers data headers))
+      (if (get-buffer-window "*eplot*" t)
+	  (set-buffer "*eplot*")
+	(if switch
+	    (pop-to-buffer-same-window "*eplot*")
+	  (pop-to-buffer "*eplot*")))
+      (let ((inhibit-read-only t))
+	(erase-buffer)
+	(unless (eq major-mode 'eplot-view-mode)
+	  (eplot-view-mode))
+	(setq-local eplot--data-buffer data-buffer)
+	(let ((chart (eplot--render data)))
+	  (with-current-buffer data-buffer
+	    (setq-local eplot--current-chart chart)))
+	(insert "\n")
+	(when-let ((win (get-buffer-window "*eplot*" t)))
+	  (set-window-point win (point-min))))
+      (select-window window))))
+
+(defun eplot--settings-table ()
+  (if (not eplot--transient-settings)
+      eplot--user-defaults
+    (append eplot--user-defaults eplot--transient-settings)))
+
+(defun eplot--inject-headers (data headers)
+  ;; It's OK not to separate the plot headers from the chart
+  ;; headers.  Collect them here, if any.
+  (when-let ((plot-headers
+	      (cl-loop for elem in (mapcar #'car eplot--plot-headers)
+		       for value = (eplot--vs elem headers)
+		       when value
+		       collect (progn
+				 ;; Remove these headers from the data
+				 ;; headers so that we don't get errors
+				 ;; on undefined headers.
+				 (setq headers (delq (assq elem headers)
+						     headers))
+				 (cons elem value)))))
+    (dolist (plot (cdr (assq :plots data)))
+      (let ((headers (assq :headers plot)))
+	(if headers
+	    (nconc headers plot-headers)
+	  (nconc plot (list (list :headers plot-headers)))))))
+  (append data headers))
+
+(defun eplot-eval-and-update ()
+  "Helper command when developing."
+  (interactive nil emacs-lisp-mode)
+  (save-some-buffers t)
+  (elisp-eval-buffer)
+  (eval-defun nil)
+  (eplot-update-view-buffer))
+
+;;; Parsing buffers.
+
+(defun eplot-update (&rest _ignore)
+  "Update the plot in the current buffer."
+  (interactive)
+  (unless eplot--data-buffer
+    (user-error "No data buffer associated with this eplot view buffer"))
+  (let ((data (with-current-buffer eplot--data-buffer
+		(eplot--parse-buffer)))
+	(eplot--user-defaults (with-current-buffer eplot--data-buffer
+				(eplot--settings-table)))
+	(inhibit-read-only t))
+    (erase-buffer)
+    (let ((chart (eplot--render data)))
+      (with-current-buffer eplot--data-buffer
+	(setq-local eplot--current-chart chart)))
+    (insert "\n\n")))
+
+(defun eplot--parse-buffer ()
+  (if (eq major-mode 'org-mode)
+      (eplot--parse-org-buffer)
+    (eplot--parse-eplot-buffer)))
+
+(defun eplot--parse-eplot-buffer ()
+  (if (eplot--csv-buffer-p)
+      (eplot--parse-csv-buffer)
+    (let ((buf (current-buffer)))
+      (with-temp-buffer
+	(insert-buffer-substring buf)
+	;; Remove comments first.
+	(goto-char (point-min))
+	(while (re-search-forward "^[ \t]*#" nil t)
+	  (delete-line))
+	(goto-char (point-min))
+	;; First headers.
+	(let* ((data (eplot--parse-headers))
+	       (plot-headers
+		;; It's OK not to separate the plot headers from the chart
+		;; headers.  Collect them here, if any.
+		(cl-loop for elem in (mapcar #'car eplot--plot-headers)
+			 for value = (eplot--vs elem data)
+			 when value
+			 collect (progn
+				   ;; Remove these headers from the data
+				   ;; headers so that we don't get errors
+				   ;; on undefined headers.
+				   (setq data (delq (assq elem data) data))
+				   (cons elem value))))
+	       plots)
+	  ;; Then the values.
+	  (while-let ((plot (eplot--parse-values nil plot-headers)))
+	    (setq plot-headers nil)
+	    (push plot plots))
+	  (when plots
+	    (push (cons :plots (nreverse plots)) data))
+	  data)))))
+
+(defun eplot--parse-headers ()
+  (let ((data nil)
+	type value)
+    (while (looking-at "\\([^\n\t :]+\\):\\(.*\\)")
+      (setq type (intern (downcase (match-string 1)))
+	    value (substring-no-properties (string-trim (match-string 2))))
+      (forward-line 1)
+      ;; Get continuation lines.
+      (while (looking-at "[ \t]+\\(.*\\)")
+	(setq value (concat value " " (string-trim (match-string 1))))
+	(forward-line 1))
+      (if (eq type 'header-file)
+	  (setq data (nconc data
+			    (with-temp-buffer
+			      (insert-file-contents value)
+			      (eplot--parse-headers))))
+	;; We don't use `push' here because we want to preserve order
+	;; also when inserting headers from other files.
+	(setq data (nconc data (list (cons type value))))))
+    data))
+
+(defun eplot--parse-values (&optional in-headers data-headers)
+  ;; Skip past separator lines.
+  (while (looking-at "[ \t]*\n")
+    (forward-line 1))
+  (let* ((values nil)
+	 ;; We may have plot-specific headers.
+	 (headers (nconc (eplot--parse-headers) data-headers))
+	 (data-format (or (eplot--vyl 'data-format headers)
+			  (eplot--vyl 'data-format in-headers)))
+	 (two-values (memq 'two-values data-format))
+	 (xy (or (memq 'year data-format)
+		 (memq 'date data-format)
+		 (memq 'time data-format)
+		 (memq 'xy data-format)))
+	 (data-column (or (eplot--vn 'data-column headers)
+			  (eplot--vn 'data-column in-headers))))
+    (if-let ((data-file (eplot--vs 'data-file headers)))
+	(with-temp-buffer
+	  (insert-file-contents data-file)
+	  (setq values (cdr (assq :values (eplot--parse-values headers)))
+		headers (delq (assq 'data headers) headers)))
+      ;; Now we come to the data.  The data is typically either just a
+      ;; number, or two numbers (in which case the first number is a
+      ;; date or a time).  Labels ans settings can be introduced with
+      ;; a # char.
+      (while (looking-at "\\([-0-9. \t]+\\)\\([ \t]*#\\(.*\\)\\)?")
+	(let ((numbers (match-string 1))
+	      (settings (eplot--parse-settings (match-string 3)))
+	      this)
+	  (setq numbers (mapcar #'string-to-number
+				(split-string (string-trim numbers))))
+	  ;; If we're reading two dimensionalish data, the first
+	  ;; number is the date/time/x.
+	  (when xy
+	    (setq this (list :x (pop numbers))))
+	  ;; Chop off all the numbers until we read the column(s)
+	  ;; we're using.
+	  (when data-column
+	    (setq numbers (nthcdr (1- data-column) numbers)))
+	  (when numbers
+	    (setq this (nconc this (list :value (pop numbers)))))
+	  (when two-values
+	    (setq this (nconc this (list :extra-value (pop numbers)))))
+	  (when settings
+	    (setq this (nconc this (list :settings settings))))
+	  (when (plist-get this :value)
+	    (push this values)))
+	(forward-line 1))
+      (setq values (nreverse values)))
+    (and values
+	 `((:headers . ,headers) (:values . ,values)))))
+
+(defun eplot--parse-settings (string)
+  (when string
+    (with-temp-buffer
+      (insert (string-trim string) "\n")
+      (goto-char (point-min))
+      (while (re-search-forward "\\(.\\)," nil t)
+	(if (equal (match-string 1) "\\")
+	    (replace-match "," t t)
+	  (delete-char -1)
+	  (insert "\n")
+	  (when (looking-at "[ \t]+")
+	    (replace-match ""))))
+      (goto-char (point-min))
+      (eplot--parse-headers))))
+
+;;; Accessing data.
+
+(defun eplot--vn (type data &optional default)
+  (if-let ((value (cdr (assq type data))))
+      (string-to-number value)
+    default))
+
+(defun eplot--vs (type data &optional default)
+  (or (cdr (assq type data)) default))
+
+(defun eplot--vy (type data &optional default)
+  (if-let ((value (cdr (assq type data))))
+      (intern (downcase value))
+    default))
+
+(defun eplot--vyl (type data &optional default)
+  (if-let ((value (cdr (assq type data))))
+      (mapcar #'intern (split-string (downcase value)))
+    default))
+
+(defmacro eplot-def (args doc-string)
+  (declare (indent defun))
+  `(eplot--def ',(nth 0 args) ',(nth 1 args) ',(nth 2 args) ',(nth 3 args)
+	       ,doc-string))
+
+(defun eplot--def (name type default valid doc)
+  (setq eplot--chart-headers (delq (assq name eplot--chart-headers)
+				   eplot--chart-headers))
+  (push (list name
+	      :type type
+	      :default default
+	      :doc doc
+	      :valid valid)
+	eplot--chart-headers))
+
+(eplot-def (width number)
+  "The width of the entire chart.")
+
+(eplot-def (height number)
+  "The height of the entire chart.")
+
+(eplot-def (format symbol normal (normal bar-chart horizontal-bar-chart))
+  "The overall format of the chart.")
+
+(eplot-def (layout symbol nil (normal compact))
+  "The general layout of the chart.")
+
+(eplot-def (mode symbol light (dark light))
+  "Dark/light mode.")
+
+(eplot-def (margin-left number 70)
+  "The left margin.")
+
+(eplot-def (margin-right number 20)
+  "The right margin.")
+
+(eplot-def (margin-top number 40)
+  "The top margin.")
+
+(eplot-def (margin-bottom number 60)
+  "The bottom margin.")
+
+(eplot-def (x-axis-title-space number 5)
+  "The space between the X axis and the label.")
+
+(eplot-def (font string "sans-serif")
+  "The font to use in titles, labels and legends.")
+
+(eplot-def (font-size number 12)
+  "The font size.")
+
+(eplot-def (font-weight symbol bold (bold normal))
+  "The font weight.")
+
+(eplot-def (label-font string (spec font))
+  "The font to use for axes labels.")
+
+(eplot-def (label-font-size number (spec font-size))
+  "The font size to use for axes labels.")
+
+(eplot-def (horizontal-label-font-size number (spec label-font-size))
+  "The font size to use for horizontal labels.")
+
+(eplot-def (bar-font string (spec font))
+  "The font to use for bar chart labels.")
+
+(eplot-def (bar-font-size number (spec font-size))
+  "The font size to use for bar chart labels.")
+
+(eplot-def (bar-font-weight symbol (spec font-weight) (bold normal))
+  "The font weight to use for bar chart labels.")
+
+(eplot-def (chart-color string "black")
+  "The foreground color to use in plots, axes, legends, etc.
+This is used as the default, but can be overridden per thing.")
+
+(eplot-def (background-color string "white")
+  "The background color.
+If you want a chart with a transparent background, use the color
+\"none\".")
+
+(eplot-def (background-gradient string)
+  "Use this to get a gradient color in the background.")
+
+(eplot-def (axes-color string (spec chart-color))
+  "The color of the axes.")
+
+(eplot-def (grid-color string "#e0e0e0")
+  "The color of the grid.")
+
+(eplot-def (grid symbol xy (xy x y off))
+  "What grid axes to do.")
+
+(eplot-def (grid-opacity number)
+  "The opacity of the grid.
+This should either be nil or a value between 0 and 1, where 0 is
+fully transparent.")
+
+(eplot-def (grid-position symbol bottom (bottom top))
+  "Whether to put the grid on top or under the plot.")
+
+(eplot-def (legend symbol nil (true nil))
+  "Whether to do a legend.")
+
+(eplot-def (legend-color string (spec chart-color))
+  "The color of legends (if any).")
+
+(eplot-def (legend-border-color string (spec chart-color))
+  "The border color of legends (if any).")
+
+(eplot-def (legend-background-color string (spec background-color))
+  "The background color of legends (if any).")
+
+(eplot-def (label-color string (spec axes-color))
+  "The color of labels on the axes.")
+
+(eplot-def (surround-color string)
+  "The color between the plot area and the edges of the chart.")
+
+(eplot-def (border-color string)
+  "The color of the border of the chart, if any.")
+
+(eplot-def (border-width number)
+  "The width of the border of the chart, if any.")
+
+(eplot-def (frame-color string)
+  "The color of the frame of the plot, if any.")
+
+(eplot-def (frame-width number)
+  "The width of the frame of the plot, if any.")
+
+(eplot-def (min number)
+  "The minimum value in the chart.
+This is normally computed automatically, but can be overridden
+ with this spec.")
+
+(eplot-def (max number)
+  "The maximum value in the chart.
+This is normally computed automatically, but can be overridden
+ with this spec.")
+
+(eplot-def (title string)
+  "The title of the chart, if any.")
+
+(eplot-def (title-color string (spec chart-color))
+  "The color of the title.")
+
+(eplot-def (x-title string)
+  "The title of the X axis, if any.")
+
+(eplot-def (y-title string)
+  "The title of the X axis, if any.")
+
+(eplot-def (x-label-format string)
+  "Format string for the X labels.
+This is a `format' string.")
+
+(eplot-def (y-label-format string)
+  "Format string for the Y labels.
+This is a `format' string.")
+
+(eplot-def (horizontal-label-left number)
+  "Position of the horizontal labels.")
+
+(eplot-def (x-label-orientation symbol horizontal (horizontal vertical))
+  "Orientation of the X labels.")
+
+(eplot-def (background-image-file string)
+  "Use an image as the background.")
+
+(eplot-def (background-image-opacity number 1)
+  "The opacity of the background image.")
+
+(eplot-def (background-image-cover symbol all (all plot frame))
+  "Position of the background image.
+Valid values are `all' (the entire image), `plot' (the plot area)
+and `frame' (the surrounding area).")
+
+(eplot-def (header-file string)
+  "File where the headers are.")
+
+(defvar eplot-compact-defaults
+  '((margin-left 30)
+    (margin-right 10)
+    (margin-top 20)
+    (margin-bottom 21)
+    (font-size 12)
+    (x-axis-title-space 3)))
+
+(defvar eplot-dark-defaults
+  '((chart-color "#c0c0c0")
+    (axes-color "#c0c0c0")
+    (grid-color "#404040")
+    (background-color "#101010")
+    (label-color "#c0c0c0")
+    (legend-color "#c0c0c0")
+    (legend-background-color "#000000")
+    (title-color "#c0c0c0")))
+
+(defvar eplot-bar-chart-defaults
+  '((grid-position top)
+    (grid y)
+    (grid-opacity 0.2)
+    (min 0)))
+
+(defvar eplot-horizontal-bar-chart-defaults
+  '((grid-position top)
+    (grid-opacity 0.2)
+    (min 0)))
+
+(defclass eplot-chart ()
+  (
+   (plots :initarg :plots)
+   (data :initarg :data)
+   (xs)
+   (ys)
+   (x-values :initform nil)
+   (x-type :initform nil)
+   (x-min)
+   (x-max)
+   (x-ticks)
+   (y-ticks)
+   (y-labels)
+   (x-labels)
+   (print-format)
+   (x-tick-step)
+   (x-label-step)
+   (x-step-map :initform nil)
+   (y-tick-step)
+   (y-label-step)
+   (inhibit-compute-x-step :initform nil)
+   ;; ---- CUT HERE ----
+   (axes-color :initarg :axes-color :initform nil)
+   (background-color :initarg :background-color :initform nil)
+   (background-gradient :initarg :background-gradient :initform nil)
+   (background-image-cover :initarg :background-image-cover :initform nil)
+   (background-image-file :initarg :background-image-file :initform nil)
+   (background-image-opacity :initarg :background-image-opacity :initform nil)
+   (bar-font :initarg :bar-font :initform nil)
+   (bar-font-size :initarg :bar-font-size :initform nil)
+   (bar-font-weight :initarg :bar-font-weight :initform nil)
+   (border-color :initarg :border-color :initform nil)
+   (border-width :initarg :border-width :initform nil)
+   (chart-color :initarg :chart-color :initform nil)
+   (font :initarg :font :initform nil)
+   (font-size :initarg :font-size :initform nil)
+   (font-weight :initarg :font-weight :initform nil)
+   (format :initarg :format :initform nil)
+   (frame-color :initarg :frame-color :initform nil)
+   (frame-width :initarg :frame-width :initform nil)
+   (grid :initarg :grid :initform nil)
+   (grid-color :initarg :grid-color :initform nil)
+   (grid-opacity :initarg :grid-opacity :initform nil)
+   (grid-position :initarg :grid-position :initform nil)
+   (header-file :initarg :header-file :initform nil)
+   (height :initarg :height :initform nil)
+   (horizontal-label-font-size :initarg :horizontal-label-font-size :initform nil)
+   (label-color :initarg :label-color :initform nil)
+   (label-font :initarg :label-font :initform nil)
+   (label-font-size :initarg :label-font-size :initform nil)
+   (layout :initarg :layout :initform nil)
+   (legend :initarg :legend :initform nil)
+   (legend-background-color :initarg :legend-background-color :initform nil)
+   (legend-border-color :initarg :legend-border-color :initform nil)
+   (legend-color :initarg :legend-color :initform nil)
+   (margin-bottom :initarg :margin-bottom :initform nil)
+   (margin-left :initarg :margin-left :initform nil)
+   (margin-right :initarg :margin-right :initform nil)
+   (margin-top :initarg :margin-top :initform nil)
+   (max :initarg :max :initform nil)
+   (min :initarg :min :initform nil)
+   (mode :initarg :mode :initform nil)
+   (surround-color :initarg :surround-color :initform nil)
+   (title :initarg :title :initform nil)
+   (title-color :initarg :title-color :initform nil)
+   (width :initarg :width :initform nil)
+   (x-axis-title-space :initarg :x-axis-title-space :initform nil)
+   (x-title :initarg :x-title :initform nil)
+   (y-title :initarg :y-title :initform nil)
+   (x-label-format :initarg :x-label-format :initform nil)
+   (x-label-orientation :initarg :x-label-orientation :initform nil)
+   (y-label-format :initarg :y-label-format :initform nil)
+   (horizontal-label-left :initarg :horizontal-label-left :initform nil)
+   ;; ---- CUT HERE ----
+   ))
+
+;;; Parameters that are plot specific.
+
+(defmacro eplot-pdef (args doc-string)
+  (declare (indent defun))
+  `(eplot--pdef ',(nth 0 args) ',(nth 1 args) ',(nth 2 args) ',(nth 3 args)
+		,doc-string))
+
+(defun eplot--pdef (name type default valid doc)
+  (setq eplot--plot-headers (delq (assq name eplot--plot-headers)
+				   eplot--plot-headers))
+  (push (list name
+	      :type type
+	      :default default
+	      :valid valid
+	      :doc doc)
+	eplot--plot-headers))
+
+(eplot-pdef (smoothing symbol nil (moving-average nil))
+  "Smoothing algorithm to apply to the data, if any.
+Valid values are `moving-average' and, er, probably more to come.")
+
+(eplot-pdef (gradient string)
+  "Gradient to apply to the plot.
+The syntax is:
+
+  from-color to-color direction position
+
+The last two parameters are optional.
+
+direction is either `top-down' (the default), `bottom-up',
+`left-right' or `right-left').
+
+position is either `below' or `above'.
+
+to-color can be either a color name, or a string that defines
+stops and colors:
+
+   Gradient: black 25-purple-50-white-75-purple-black
+
+In that case, the second element specifies the percentage points
+of where each color ends, so the above starts with black, then at
+25% it's purple, then at 50% it's white, then it's back to purple
+again at 75%, before ending up at black at a 100% (but you don't
+have to include the 100% here -- it's understood).")
+
+(eplot-pdef (style symbol line ( line impulse point square circle cross
+				 triangle rectangle curve))
+  "Style the plot should be drawn in.
+Valid values are listed below.  Some styles take additional
+optional parameters.
+
+line
+  Straight lines between values.
+
+curve
+  Curved lines between values.
+
+impulse
+  size: width of the impulse
+
+point
+
+square
+
+circle
+  size: diameter of the circle
+  fill-color: color to fill the center
+
+cross
+  size: length of the lines in the cross
+
+triangle
+  size: length of the sides of the triangle
+  fill-color: color to fill the center
+
+rectangle
+  size: length of the sides of the rectangle
+  fill-color: color to fill the center")
+
+(eplot-pdef (fill-color string)
+  "Color to use to fill the plot styles that are closed shapes.
+I.e., circle, triangle and rectangle.")
+
+(eplot-pdef (color string (spec chart-color))
+  "Color to draw the plot.")
+
+(eplot-pdef (data-format symbol single (single date time xy))
+  "Format of the data.
+By default, eplot assumes that each line has a single data point.
+This can also be `date', `time' and `xy'.
+
+date: The first column is a date on ISO8601 format (i.e., YYYYMMDD).
+
+time: The first column is a clock (i.e., HHMMSS).
+
+xy: The first column is the X position.")
+
+(eplot-pdef (data-column number 1)
+  "Column where the data is.")
+
+(eplot-pdef (fill-border-color string)
+  "Border around the fill area when using a fill/gradient style.")
+
+(eplot-pdef (size number)
+  "Size of elements in styles that have meaningful sizes.")
+
+(eplot-pdef (size-factor number)
+  "Multiply the size of the elements by the value.")
+
+(eplot-pdef (data-file string)
+  "File where the data is.")
+
+(eplot-pdef (data-format symbol-list nil (nil two-values date time))
+  "List of symbols to describe the data format.
+Elements allowed are `two-values', `date' and `time'.")
+
+(eplot-pdef (name string)
+  "Name of the plot, which will be displayed if legends are switched on.")
+
+(eplot-pdef (legend-color string (spec chart-color))
+  "Color for the name to be displayed in the legend.")
+
+(eplot-pdef (bezier-factor number 0.1)
+  "The Bezier factor to apply to curve plots.")
+
+(eplot-pdef (bar-max-width number)
+  "Max width of bars in bar plots.")
+
+(defclass eplot-plot ()
+  (
+   (values :initarg :values)
+   ;; ---- CUT HERE ----
+   (bar-max-width :initarg :bar-max-width :initform nil)
+   (bezier-factor :initarg :bezier-factor :initform nil)
+   (color :initarg :color :initform nil)
+   (data-column :initarg :data-column :initform nil)
+   (data-file :initarg :data-file :initform nil)
+   (data-format :initarg :data-format :initform nil)
+   (fill-border-color :initarg :fill-border-color :initform nil)
+   (fill-color :initarg :fill-color :initform nil)
+   (gradient :initarg :gradient :initform nil)
+   (legend-color :initarg :legend-color :initform nil)
+   (name :initarg :name :initform nil)
+   (size :initarg :size :initform nil)
+   (size-factor :initarg :size-factor :initform nil)
+   (smoothing :initarg :smoothing :initform nil)
+   (style :initarg :style :initform nil)
+   ;; ---- CUT HERE ----
+   ))
+
+(defun eplot--make-plot (data)
+  "Make an `eplot-plot' object and initialize based on DATA."
+  (let ((plot (make-instance 'eplot-plot
+			     :values (cdr (assq :values data)))))
+    ;; Get the program-defined defaults.
+    (eplot--object-defaults plot eplot--plot-headers)
+    ;; One special case.  I don't think this hack is quite right...
+    (when (or (eq (eplot--vs 'mode data) 'dark)
+	      (eq (cdr (assq 'mode eplot--user-defaults)) 'dark))
+      (setf (slot-value plot 'color) "#c0c0c0"))
+    ;; Use the headers.
+    (eplot--object-values plot (cdr (assq :headers data)) eplot--plot-headers)
+    plot))
+
+(defun eplot--make-chart (data)
+  "Make an `eplot-chart' object and initialize based on DATA."
+  (let ((chart (make-instance 'eplot-chart
+			      :plots (mapcar #'eplot--make-plot
+					     (eplot--vs :plots data))
+			      :data data)))
+    ;; First get the program-defined defaults.
+    (eplot--object-defaults chart eplot--chart-headers)
+    ;; Then do the "meta" variables.
+    (eplot--meta chart data 'mode 'dark eplot-dark-defaults)
+    (eplot--meta chart data 'layout 'compact eplot-compact-defaults)
+    (eplot--meta chart data 'format 'bar-chart eplot-bar-chart-defaults)
+    (eplot--meta chart data 'format 'horizontal-bar-chart
+		 eplot-horizontal-bar-chart-defaults)
+    ;; Set defaults from user settings/transients.
+    (cl-loop for (name . value) in eplot--user-defaults
+	     when (assq name eplot--chart-headers)
+	     do
+	     (setf (slot-value chart name) value)
+	     (eplot--set-dependent-values chart name value))
+    ;; Finally, use the data from the chart.
+    (eplot--object-values chart data eplot--chart-headers)
+    ;; If not set, recompute the margins based on the font sizes (if
+    ;; the font size has been changed from defaults).
+    (when (or (assq 'font-size eplot--user-defaults)
+	      (assq 'font-size data))
+      (with-slots ( title x-title y-title
+		    margin-top margin-bottom margin-left
+		    font-size font font-weight)
+	  chart
+	(when (or title x-title y-title)
+	  (let ((text-height
+		 (eplot--text-height (concat title x-title y-title)
+				     font font-size font-weight)))
+	    (when (and title
+		       (and (not (assq 'margin-top eplot--user-defaults))
+			    (not (assq 'margin-top data))))
+	      (cl-incf margin-top (* text-height 1.4)))
+	    (when (and x-title
+		       (and (not (assq 'margin-bottom eplot--user-defaults))
+			    (not (assq 'margin-bottom data))))
+	      (cl-incf margin-bottom (* text-height 1.4)))
+	    (when (and y-title
+		       (and (not (assq 'margin-left eplot--user-defaults))
+			    (not (assq 'margin-left data))))
+	      (cl-incf margin-left (* text-height 1.4)))))))
+    chart))
+
+(defun eplot--meta (chart data slot value defaults)
+  (when (or (eq (cdr (assq slot eplot--user-defaults)) value)
+	    (eq (eplot--vy slot data) value))
+    (eplot--set-theme chart defaults)))
+
+(defun eplot--object-defaults (object headers)
+  (dolist (header headers)
+    (when-let ((default (plist-get (cdr header) :default)))
+      (setf (slot-value object (car header))
+	    ;; Allow overrides via `eplot-set'.
+	    (or (cdr (assq (car header) eplot--user-defaults))
+		(if (and (consp default)
+			 (eq (car default) 'spec))
+		    ;; Chase dependencies.
+		    (eplot--default (cadr default))
+		  default))))))
+
+(defun eplot--object-values (object data headers)
+  (cl-loop for (name . value) in data
+	   do (unless (eq name :plots)
+		(let ((spec (cdr (assq name headers))))
+		  (if (not spec)
+		      (error "%s is not a valid spec" name)
+		    (let ((value 
+			   (cl-case (plist-get spec :type)
+			     (number
+			      (string-to-number value))
+			     (symbol
+			      (intern (downcase value)))
+			     (symbol-list
+			      (mapcar #'intern (split-string (downcase value))))
+			     (t
+			      value))))
+		      (setf (slot-value object name) value)
+		      (eplot--set-dependent-values object name value)))))))
+
+(defun eplot--set-dependent-values (object name value)
+  (dolist (slot (gethash name (eplot--dependecy-graph)))
+    (setf (slot-value object slot) value)
+    (eplot--set-dependent-values object slot value)))
+
+(defun eplot--set-theme (chart map)
+  (cl-loop for (slot value) in map
+	   do (setf (slot-value chart slot) value)))
+
+(defun eplot--default (slot)
+  "Find the default value for SLOT, chasing dependencies."
+  (let ((spec (cdr (assq slot eplot--chart-headers))))
+    (unless spec
+      (error "Invalid slot %s" slot))
+    (let ((default (plist-get spec :default)))
+      (if (and (consp default)
+	       (eq (car default) 'spec))
+	  (eplot--default (cadr default))
+	(or (cdr (assq slot eplot--user-defaults)) default)))))
+
+(defun eplot--dependecy-graph ()
+  (let ((table (make-hash-table)))
+    (dolist (elem eplot--chart-headers)
+      (let ((default (plist-get (cdr elem) :default)))
+	(when (and (consp default)
+		   (eq (car default) 'spec))
+	  (push (car elem) (gethash (cadr default) table)))))
+    table))
+
+(defun eplot--render (data &optional return-image)
+  "Create the chart and display it.
+If RETURN-IMAGE is non-nil, return it instead of displaying it."
+  (let* ((chart (eplot--make-chart data))
+	 svg)
+    (with-slots ( width height xs ys
+		  margin-left margin-right margin-top margin-bottom
+		  grid-position plots x-min format
+		  x-label-orientation)
+	chart
+      ;; Set the size of the chart based on the window it's going to
+      ;; be displayed in.  It uses the *eplot* window by default, or
+      ;; the current one if that isn't displayed.
+      (let ((factor (image-compute-scaling-factor image-scaling-factor)))
+	(unless width
+	  (setq width (truncate
+		       (/ (* (window-pixel-width
+ 			      (get-buffer-window "*eplot*" t))
+			     0.9)
+			  factor))))
+	(unless height
+	  (setq height (truncate
+			(/ (* (window-pixel-height
+			       (get-buffer-window "*eplot*" t))
+			      0.9)
+			   factor)))))
+      (setq svg (svg-create width height)
+	    xs (- width margin-left margin-right)
+	    ys (- height margin-top margin-bottom))
+      ;; Protect against being called in an empty buffer.
+      (if (not (and plots
+		    ;; Sanity check against the user choosing dimensions
+		    ;; that leave no space for the plot.
+		    (> ys 0) (> xs 0)))
+	  ;; Just draw the basics.
+	  (eplot--draw-basics svg chart)
+
+	;; Horizontal bar charts are special.
+	(when (eq format 'horizontal-bar-chart)
+	  (eplot--adjust-horizontal-bar-chart chart data))
+	;; Compute min/max based on all plots, and also compute x-ticks
+	;; etc.
+	(eplot--compute-chart-dimensions chart)
+	(when (and (eq x-label-orientation 'vertical)
+		   (eplot--default-p 'margin-bottom (slot-value chart 'data)))
+	  (eplot--adjust-vertical-x-labels chart))
+	;; Analyze values and adjust values accordingly.
+	(eplot--adjust-chart chart)
+	;; Compute the Y labels -- this may adjust `margin-left'.
+	(eplot--compute-y-labels chart)
+	;; Compute the X labels -- this may adjust `margin-bottom'.
+	(eplot--compute-x-labels chart)
+	;; Draw background/borders/titles/etc.
+	(eplot--draw-basics svg chart)
+
+	(when (eq grid-position 'top)
+	  (eplot--draw-plots svg chart))
+
+	(eplot--draw-x-ticks svg chart)
+	(unless (eq format 'horizontal-bar-chart)
+	  (eplot--draw-y-ticks svg chart))
+      
+	;; Draw axes.
+	(with-slots ( margin-left margin-right margin-margin-top
+		      margin-bottom axes-color)
+	    chart
+	  (svg-line svg margin-left margin-top margin-left
+		    (+ (- height margin-bottom) 5)
+		    :stroke axes-color)
+	  (svg-line svg (- margin-left 5) (- height margin-bottom)
+		    (- width margin-right) (- height margin-bottom)
+		    :stroke axes-color))
+    
+	(when (eq grid-position 'bottom)
+	  (eplot--draw-plots svg chart)))
+
+      (with-slots (frame-color frame-width) chart
+	(when (or frame-color frame-width)
+	  (svg-rectangle svg margin-left margin-top xs ys
+			 :stroke-width frame-width
+			 :fill "none"
+			 :stroke-color frame-color)))
+      (eplot--draw-legend svg chart))
+
+    (if return-image
+	svg
+      (svg-insert-image svg)
+      chart)))
+
+(defun eplot--adjust-horizontal-bar-chart (chart data)
+  (with-slots ( plots bar-font bar-font-size bar-font-weight margin-left
+		width margin-right xs)
+      chart
+    (dolist (plot plots)
+      (with-slots ( data-format values) plot
+	(push 'xy data-format)
+	;; Flip the values -- we want the values to be on the X
+	;; axis instead.
+	(setf values
+	      (cl-loop for value in values
+		       for i from 1
+		       collect (list :value i
+				     :x (plist-get value :value)
+				     :settings
+				     (plist-get value :settings))))
+	(when (eplot--default-p 'margin-left data)
+	  (setf margin-left
+		(+ (cl-loop for value in values
+			    maximize
+			    (eplot--text-width
+			     (eplot--vs 'label (plist-get value :settings))
+			     bar-font bar-font-size bar-font-weight))
+		   20)
+		xs (- width margin-left margin-right)))))))
+
+(defun eplot--draw-basics (svg chart)
+  (with-slots ( width height 
+		chart-color font font-size font-weight
+		margin-left margin-right margin-top margin-bottom
+		background-color label-color
+		xs ys)
+      chart
+    ;; Add background.
+    (eplot--draw-background chart svg 0 0 width height)
+    (with-slots ( background-image-file background-image-opacity
+		  background-image-cover)
+	chart
+      (when (and background-image-file
+		 ;; Sanity checks to avoid erroring out later.
+		 (file-exists-p background-image-file)
+		 (file-regular-p background-image-file))
+	(apply #'svg-embed svg background-image-file "image/jpeg" nil
+	       :opacity background-image-opacity
+	       :preserveAspectRatio "xMidYMid slice"
+	       (if (memq background-image-cover '(all frame))
+		   `(:x 0 :y 0 :width ,width :height ,height)
+		 `(:x ,margin-left :y ,margin-top :width ,xs :height ,ys)))
+	(when (eq background-image-cover 'frame)
+	  (eplot--draw-background chart svg margin-left margin-right xs ys))))
+    ;; Area between plot and edges.
+    (with-slots (surround-color) chart
+      (when surround-color
+	(svg-rectangle svg 0 0 width height
+		       :fill surround-color)
+	(svg-rectangle svg margin-left margin-top
+		       xs ys
+		       :fill background-color)))
+    ;; Border around the entire chart.
+    (with-slots (border-width border-color) chart
+      (when (or border-width border-color)
+	(svg-rectangle svg 0 0 width height
+		       :stroke-width (or border-width 1)
+		       :fill "none"
+		       :stroke-color (or border-color chart-color))))
+    ;; Frame around the plot.
+    (with-slots (frame-width frame-color) chart
+      (when (or frame-width frame-color)
+	(svg-rectangle svg margin-left margin-top xs ys
+		       :stroke-width (or frame-width 1)
+		       :fill "none"
+		       :stroke-color (or frame-color chart-color))))
+    ;; Title and legends.
+    (with-slots (title title-color) chart
+      (when title
+	(svg-text svg title
+		  :font-family font
+		  :text-anchor "middle"
+		  :font-weight font-weight
+		  :font-size font-size
+		  :fill title-color
+		  :x (+ margin-left (/ (- width margin-left margin-right) 2))
+		  :y (+ 3 (/ margin-top 2)))))
+    (with-slots (x-title) chart
+      (when x-title
+	(svg-text svg x-title
+		  :font-family font
+		  :text-anchor "middle"
+		  :font-weight font-weight
+		  :font-size font-size
+		  :fill label-color
+		  :x (+ margin-left (/ (- width margin-left margin-right) 2))
+		  :y (- height (/ margin-bottom 4)))))
+    (with-slots (y-title) chart
+      (when y-title
+	(let ((text-height
+	       (eplot--text-height y-title font font-size font-weight)))
+	  (svg-text svg y-title
+		    :font-family font
+		    :text-anchor "middle"
+		    :font-weight font-weight
+		    :font-size font-size
+		    :fill label-color
+		    :transform
+		    (format "translate(%s,%s) rotate(-90)"
+			    (- (/ margin-left 2) (/ text-height 2) 4)
+			    (+ margin-top
+			       (/ (- height margin-bottom margin-top) 2)))))))))
+
+(defun eplot--draw-background (chart svg left top width height)
+  (with-slots (background-gradient background-color) chart
+    (let ((gradient (eplot--parse-gradient background-gradient))
+	  id)
+      (when gradient
+	(setq id (format "gradient-%s" (make-temp-name "grad")))
+	(eplot--gradient svg id 'linear
+			 (eplot--stops (eplot--vs 'from gradient)
+				       (eplot--vs 'to gradient))
+			 (eplot--vs 'direction gradient)))
+      (apply #'svg-rectangle svg left top width height
+	     (if gradient
+		 `(:gradient ,id)
+	       `(:fill ,background-color))))))
+
+(defun eplot--compute-chart-dimensions (chart)
+  (with-slots ( min max plots x-values x-min x-max x-ticks
+		print-format font-size
+		xs
+		inhibit-compute-x-step x-type x-step-map format
+		x-tick-step x-label-step
+		label-font label-font-size x-label-format)
+      chart
+    (let ((set-min min)
+	  (set-max max))
+      (dolist (plot plots)
+	(with-slots (values data-format) plot
+	  (let* ((vals (nconc (seq-map (lambda (v) (plist-get v :value)) values)
+			      (and (memq 'two-values data-format)
+				   (seq-map
+				    (lambda (v) (plist-get v :extra-value))
+				    values)))))
+	    ;; Set the x-values based on the first plot.
+	    (unless x-values
+	      (setq print-format (cond
+				  ((memq 'year data-format) 'year)
+				  ((memq 'date data-format) 'date)
+				  ((memq 'time data-format) 'time)
+				  (t 'number)))
+	      (cond
+	       ((or (memq 'xy data-format)
+		    (memq 'year data-format))
+		(setq x-values (cl-loop for val in values
+					collect (plist-get val :x))
+		      x-min (if (eq format 'horizontal-bar-chart)
+				0
+			      (seq-min x-values))
+		      x-max (seq-max x-values)
+		      x-ticks (eplot--get-ticks x-min x-max xs))
+		(when (memq 'year data-format)
+		  (setq print-format 'literal-year)))
+	       ((memq 'date data-format)
+		(setq x-values
+		      (cl-loop for val in values
+			       collect
+			       (time-to-days
+				(encode-time
+				 (decoded-time-set-defaults
+				  (iso8601-parse-date
+				   (format "%d" (plist-get val :x)))))))
+		      x-min (seq-min x-values)
+		      x-max (seq-max x-values)
+		      inhibit-compute-x-step t)
+		(let ((xs (eplot--get-date-ticks
+			   x-min x-max xs
+			   label-font label-font-size x-label-format)))
+		  (setq x-ticks (car xs)
+			print-format (cadr xs)
+			x-tick-step 1
+			x-label-step 1
+			x-step-map (nth 2 xs))))
+	       ((memq 'time data-format)
+		(setq x-values
+		      (cl-loop for val in values
+			       collect
+			       (time-convert
+				(encode-time
+				 (decoded-time-set-defaults
+				  (iso8601-parse-time
+				   (format "%06d" (plist-get val :x)))))
+				'integer))
+		      x-min (car x-values)
+		      x-max (car (last x-values))
+		      inhibit-compute-x-step t)
+		(let ((xs (eplot--get-time-ticks
+			   x-min x-max xs label-font label-font-size
+			   x-label-format)))
+		  (setq x-ticks (car xs)
+			print-format (cadr xs)
+			x-tick-step 1
+			x-label-step 1
+			x-step-map (nth 2 xs))))
+	       (t
+		;; This is a one-dimensional plot -- we don't have X
+		;; values, really, so we just do zero to (1- (length
+		;; values)).
+		(setq x-type 'one-dimensional
+		      x-values (cl-loop for i from 0
+					repeat (length values)
+					collect i)
+		      x-min (car x-values)
+		      x-max (car (last x-values))
+		      x-ticks x-values))))
+	    (unless set-min
+	      (setq min (min (or min 1.0e+INF) (seq-min vals))))
+	    (unless set-max
+	      (setq max (max (or max -1.0e+INF) (seq-max vals))))))))))
+
+(defun eplot--adjust-chart (chart)
+  (with-slots ( x-tick-step x-label-step y-tick-step y-label-step
+		min max ys format inhibit-compute-x-step
+		y-ticks xs x-values print-format
+		x-label-format label-font label-font-size data
+		x-ticks)
+      chart
+    (setq y-ticks (and max
+		       (eplot--get-ticks
+			min
+			;; We get 5% more ticks to check whether we
+			;; should extend max.
+			(if (eplot--default-p 'max data)
+			    (* max 1.05)
+			  max)
+			ys)))
+    (when (eplot--default-p 'max data)
+      (setq max (max max (car (last y-ticks)))))
+    (if (eq format 'bar-chart)
+	(setq x-tick-step 1
+	      x-label-step 1)
+      (unless inhibit-compute-x-step
+	(let ((xt (eplot--compute-x-ticks
+		   xs x-ticks print-format
+		   x-label-format label-font label-font-size)))
+	  (setq x-tick-step (car xt)
+		x-label-step (cadr xt)))))
+    (when max
+      (let ((yt (eplot--compute-y-ticks
+		 ys y-ticks
+		 (eplot--text-height "100" label-font label-font-size))))
+	(setq y-tick-step (car yt)
+	      y-label-step (cadr yt))))
+    ;; If max is less than 2% off from a pleasant number, then
+    ;; increase max.
+    (when (eplot--default-p 'max data)
+      (cl-loop for tick in (reverse y-ticks)
+	       when (and (< max tick)
+			 (< (e/ (- tick max) (- max min)) 0.02))
+	       return (progn
+			(setq max tick)
+			;; Chop off any further ticks.
+			(setcdr (member tick y-ticks) nil))))
+
+    (when y-ticks
+      (if (and (eplot--default-p 'min data)
+	       (< (car y-ticks) min))
+	  (setq min (car y-ticks))
+	;; We may be extending the bottom of the chart to get pleasing
+	;; numbers.  We don't want to be drawing the chart on top of the
+	;; X axis, because the chart won't be visible there.
+	(when (and nil
+		   (<= min (car y-ticks))
+		   ;; But not if we start at origo, because that just
+		   ;; looks confusing.
+		   (not (zerop min)))
+	  (setq min (- (car y-ticks)
+		       ;; 2% of the value range.
+		       (* 0.02 (- (car (last y-ticks)) (car y-ticks))))))))))
+
+(defun eplot--adjust-vertical-x-labels (chart)
+  (with-slots ( x-step-map x-ticks format plots
+		print-format x-label-format label-font
+		label-font-size margin-bottom
+		bar-font bar-font-size bar-font-weight)
+      chart
+    ;; Make X ticks.
+    (let ((width
+	   (cl-loop
+	    for xv in (or x-step-map x-ticks)
+	    for x = (if (consp xv) (car xv) xv)
+	    for i from 0
+	    for value = (and (equal format 'bar-chart)
+			     (elt (slot-value (car plots) 'values) i))
+	    for label = (if (equal format 'bar-chart)
+			    (eplot--vs 'label
+				       (plist-get value :settings)
+				       ;; When we're doing bar charts, we
+				       ;; want default labeling to start with
+				       ;; 1 and not zero.
+				       (format "%s" (1+ x)))
+			  (eplot--format-value x print-format x-label-format))
+	    maximize (if (equal format 'bar-chart)
+			 (eplot--text-width
+			  label bar-font bar-font-size bar-font-weight)
+		       (eplot--text-width
+			label label-font label-font-size)))))
+      ;; Ensure that we have enough room to display the X labels
+      ;; (unless overridden).
+      (with-slots ( height margin-top ys
+		    y-ticks y-tick-step y-label-step min max)
+	  chart
+	(setq margin-bottom (max margin-bottom (+ width 40))
+	      ys (- height margin-top margin-bottom))))))
+
+(defun eplot--compute-x-labels (chart)
+  (with-slots ( x-step-map x-ticks
+		format plots print-format x-label-format x-labels
+		x-tick-step x-label-step
+		x-label-orientation margin-bottom)
+      chart
+    ;; Make X ticks.
+    (setf x-labels
+	  (cl-loop
+	   for xv in (or x-step-map x-ticks)
+	   for x = (if (consp xv) (car xv) xv)
+	   for do-tick = (if (consp xv)
+			     (nth 1 xv)
+			   (zerop (e% x x-tick-step)))
+	   for do-label = (if (consp xv)
+			      (nth 2 xv)
+			    (zerop (e% x x-label-step)))
+	   for i from 0
+	   for value = (and (equal format 'bar-chart)
+			    (elt (slot-value (car plots) 'values) i))
+	   collect (list
+		    (if (equal format 'bar-chart)
+			(eplot--vs 'label
+				   (plist-get value :settings)
+				   ;; When we're doing bar charts, we
+				   ;; want default labeling to start with
+				   ;; 1 and not zero.
+				   (format "%s" (1+ x)))
+		      (eplot--format-value x print-format x-label-format))
+		    do-tick
+		    do-label)))))
+
+(defun eplot--draw-x-ticks (svg chart)
+  (with-slots ( x-step-map x-ticks format layout print-format
+		margin-left margin-right margin-top margin-bottom
+		x-min x-max xs
+		width height
+		axes-color label-color
+		grid grid-opacity grid-color
+		font x-tick-step x-label-step x-label-format x-label-orientation
+		label-font label-font-size
+		plots x-labels
+		x-values
+		bar-font bar-font-size bar-font-weight
+		plots)
+      chart
+    (let ((font label-font)
+	  (font-size label-font-size)
+	  (font-weight 'normal)
+	  (label-settings nil))
+      (when (equal format 'bar-chart)
+	(setq font bar-font
+	      font-size bar-font-size
+	      font-weight bar-font-weight
+	      label-settings (mapcar (lambda (e)
+				       (plist-get e :settings))
+				     (slot-value (car plots) 'values))))
+      ;; Make X ticks.
+      (cl-loop with label-height
+	       for xv in (or x-step-map x-ticks)
+	       for x = (if (consp xv) (car xv) xv)
+	       for i from 0
+	       for (label do-tick do-label) in x-labels
+	       for px = (if (equal format 'bar-chart)
+			    (+ margin-left
+			       (/ (/ xs (length x-values)) 2)
+			       (* (e/ i (length x-values))
+				  xs))
+			  (+ margin-left
+			     (* (/ (- (* 1.0 x) x-min) (- x-max x-min))
+				xs)))
+	       for this-font-weight =
+	       (if (equal format 'bar-chart)
+		   (or (cdr (assq 'label-font-weight (nth i label-settings)))
+		       font-weight)
+		 font-weight)
+	       ;; We might have one extra stride outside the area -- don't
+	       ;; draw it.
+	       when (<= px (- width margin-right))
+	       do
+	       (when do-tick
+		 ;; Draw little tick.
+		 (unless (equal format 'bar-chart)
+		   (svg-line svg
+			     px (- height margin-bottom)
+			     px (+ (- height margin-bottom)
+				   (if do-label
+				       4
+				     2))
+			     :stroke axes-color))
+		 (when (or (eq grid 'xy) (eq grid 'x))
+		   (svg-line svg px margin-top
+			     px (- height margin-bottom)
+			     :opacity grid-opacity
+			     :stroke grid-color)))
+	       (when (and do-label
+			  ;; We want to skip marking the first X value
+			  ;; unless we're a bar chart or we're a one
+			  ;; dimensional chart.
+			  (or (equal format 'bar-chart)
+			      t
+			      (not (= x-min (car x-values)))
+			      (eq x-type 'one-dimensional)
+			      (and (not (zerop x)) (not (zerop i)))))
+		 (if (eq x-label-orientation 'vertical)
+		     (progn
+		       (unless label-height
+			 ;; The X position we're putting the label at is
+			 ;; based on the bottom of the lower-case
+			 ;; characters.  So we want to ignore descenders
+			 ;; etc, so we use "xx" to determine the height
+			 ;; to be able to center the text.
+			 (setq label-height
+			       (eplot--text-height
+				;; If the labels are numerical, we need
+				;; to center them using the height of
+				;; numbers.
+				(if (string-match "^[0-9]+$" label)
+				    "10"
+				  ;; Otherwise center them on the baseline.
+				  "xx")
+				font font-size this-font-weight)))
+		       (svg-text svg label
+				 :font-family font
+				 :text-anchor "end"
+				 :font-size font-size
+				 :font-weight this-font-weight
+				 :fill label-color
+				 :transform
+				 (format "translate(%s,%s) rotate(-90)"
+					 (+ px (/ label-height 2))
+					 (- height margin-bottom -10))))
+		   (svg-text svg label
+			     :font-family font
+			     :text-anchor "middle"
+			     :font-size font-size
+			     :font-weight this-font-weight
+			     :fill label-color
+			     :x px
+			     :y (+ (- height margin-bottom)
+				   font-size
+				   (if (equal format 'bar-chart)
+				       (if (equal layout 'compact) 3 5)
+				     2)))))))))
+
+(defun eplot--stride (chart values)
+  (with-slots (xs x-type format) chart
+    (if (eq x-type 'one-dimensional)
+	(e/ xs
+	    ;; Fenceposting bar-chart vs everything else.
+	    (if (eq format 'bar-chart)
+		(length values)
+	      (1- (length values))))
+      (e/ xs (length values)))))
+
+(defun eplot--default-p (slot data)
+  "Return non-nil if SLOT is at the default value."
+  (and (not (assq slot eplot--user-defaults))
+       (not (assq slot data))))
+
+(defun eplot--compute-y-labels (chart)
+  (with-slots ( y-ticks y-labels
+		width height min max xs ys
+		margin-top margin-bottom margin-left margin-right
+		y-tick-step y-label-step y-label-format)
+      chart
+    ;; First collect all the labels we're thinking about outputting.
+    (setq y-labels
+	  (cl-loop for y in y-ticks
+		   for py = (- (- height margin-bottom)
+			       (* (/ (- (* 1.0 y) min) (- max min))
+				  ys))
+		   when (and (<= margin-top py (- height margin-bottom))
+			     (zerop (e% y y-tick-step))
+			     (zerop (e% y y-label-step)))
+		   collect (eplot--format-y
+			    y (- (cadr y-ticks) (car y-ticks)) nil
+			    y-label-format)))
+    ;; Check the labels to see whether we have too many digits for
+    ;; what we're actually going to display.  Man, this is a lot of
+    ;; back-and-forth and should be rewritten to be less insanely
+    ;; inefficient.
+    (when (= (seq-count (lambda (label)
+			  (string-match "\\." label))
+			y-labels)
+	     (length y-labels))
+      (setq y-labels
+	    (cl-loop with max = (cl-loop for label in y-labels
+					 maximize (eplot--decimal-digits
+						   (string-to-number label)))
+		     for label in y-labels
+		     collect (format (if (zerop max)
+					 "%d"
+				       (format "%%.%df" max))
+				     (string-to-number label)))))
+    (setq y-labels (cl-coerce y-labels 'vector))
+    ;; Ensure that we have enough room to display the Y labels
+    ;; (unless overridden).
+    (when (eplot--default-p 'margin-left (slot-value chart 'data))
+      (with-slots (label-font label-font-size) chart
+	(setq margin-left (max margin-left
+			       (+ (eplot--text-width
+				   (elt y-labels (1- (length y-labels)))
+				   label-font label-font-size)
+				  10))
+	      xs (- width margin-left margin-right))))))
+
+(defun eplot--draw-y-ticks (svg chart)
+  (with-slots ( y-ticks y-labels y-tick-step y-label-step label-color
+		label-font label-font-size
+		width height min max ys
+		margin-top margin-bottom margin-left margin-right
+		axes-color
+		grid grid-opacity grid-color)
+      chart
+    ;; Make Y ticks.
+    (cl-loop with lnum = 0
+	     with text-height = (eplot--text-height
+				 "012" label-font label-font-size)
+	     for y in y-ticks
+	     for i from 0
+	     for py = (- (- height margin-bottom)
+			 (* (/ (- (* 1.0 y) min) (- max min))
+			    ys))
+	     do
+	     (when (and (<= margin-top py (- height margin-bottom))
+			(zerop (e% y y-tick-step)))
+	       (svg-line svg margin-left py
+			 (- margin-left 3) py
+			 :stroke-color axes-color)
+	       (when (or (eq grid 'xy) (eq grid 'y))
+		 (svg-line svg margin-left py
+			   (- width margin-right) py
+			   :opacity grid-opacity
+			   :stroke-color grid-color))
+	       (when (zerop (e% y y-label-step))
+		 (svg-text svg (elt y-labels lnum)
+			   :font-family label-font
+			   :text-anchor "end"
+			   :font-size label-font-size
+			   :fill label-color
+			   :x (- margin-left 6)
+			   :y (+ py (/ text-height 2) -1))
+		 (cl-incf lnum))))))
+
+(defun eplot--text-width (text font font-size &optional font-weight)
+  (string-pixel-width
+   (propertize text 'face
+	       (list :font (font-spec :family font
+				      :weight (or font-weight 'normal)
+				      :size font-size)))))
+
+(defvar eplot--text-size-cache (make-hash-table :test #'equal))
+
+(defun eplot--text-height (text font font-size &optional font-weight)
+  (cdr (eplot--text-size text font font-size font-weight)))
+
+(defun eplot--text-size (text font font-size font-weight)
+  (let ((key (list text font font-size font-weight)))
+    (or (gethash key eplot--text-size-cache)
+	(let ((size (eplot--text-size-1 text font font-size font-weight)))
+	  (setf (gethash key eplot--text-size-cache) size)
+	  size))))
+
+(defun eplot--text-size-1 (text font font-size font-weight)
+  (if (not (executable-find "convert"))
+      ;; This "default" text size is kinda bogus.
+      (cons (* (length text) font-size) font-size)
+    (let* ((size (* font-size 10))
+	   (svg (svg-create size size))
+	   text-size)
+      (svg-rectangle svg 0 0 size size :fill "black")
+      (svg-text svg text
+		:font-family font
+		:text-anchor "middle"
+		:font-size font-size
+		:font-weight (or font-weight 'normal)
+		:fill "white"
+		:x (/ size 2)
+		:y (/ size 2))
+      (with-temp-buffer
+	(set-buffer-multibyte nil)
+	(svg-print svg)
+	(let* ((file (make-temp-file "eplot" nil ".svg"))
+	       (png (file-name-with-extension file ".png")))
+	  (unwind-protect
+	      (progn
+		(write-region (point-min) (point-max) file nil 'silent)
+		;; rsvg-convert is 5x faster than convert when doing SVG, so
+		;; if we have it, we use it.
+		(when (executable-find "rsvg-convert")
+		  (unwind-protect
+		      (call-process "rsvg-convert" nil nil nil
+				    (format "--output=%s" png) file)
+		    (when (file-exists-p png)
+		      (delete-file file)
+		      (setq file png))))
+		(erase-buffer)
+		(when (zerop (call-process "convert" nil t nil
+					   "-trim" "+repage" file "info:-"))
+		  (goto-char (point-min))
+		  (when (re-search-forward " \\([0-9]+\\)x\\([0-9]+\\)" nil t)
+		    (setq text-size
+			  (cons (string-to-number (match-string 1))
+				(string-to-number (match-string 2)))))))
+	    (when (file-exists-p file)
+	      (delete-file file)))))
+      (or text-size
+	  ;; This "default" text size is kinda bogus.
+	  (cons (* (length text) font-size) font-size)))))
+
+(defun eplot--draw-legend (svg chart)
+  (with-slots ( legend plots
+		margin-left margin-top
+		font font-size font-weight
+		background-color axes-color
+		legend-color legend-background-color legend-border-color)
+      chart
+    (when (eq legend 'true)
+      (when-let ((names
+		  (cl-loop for plot in plots
+			   for name = (slot-value plot 'name)
+			   when name
+			   collect
+			   (cons name (slot-value plot 'color)))))
+	(svg-rectangle svg (+ margin-left 20) (+ margin-top 20)
+		       (format "%dpx"
+			       (+ 10
+				  (seq-max
+				   (mapcar (lambda (name)
+					     (eplot--text-width (car name)
+								font font-size))
+					   names))))
+		       (* font-size (+ (length names) 2))
+		       :font-size font-size
+		       :fill-color legend-background-color
+		       :stroke-color legend-border-color)
+	(cl-loop for name in names
+		 for i from 0
+		 do (svg-text svg (car name)
+			      :font-family font
+			      :text-anchor "front"
+			      :font-size font-size
+			      :font-weight font-weight
+			      :fill (or (cdr name) legend-color)
+			      :x (+ margin-left 25)
+			      :y (+ margin-top 40 (* i font-size))))))))
+
+(defun eplot--format-y (y spacing whole format-string)
+  (format (or format-string "%s")
+	  (cond
+	   ((or (= (round (* spacing 100)) 10) (= (round (* spacing 100)) 20))
+	    (format "%.1f" y))
+	   ((< spacing 0.01)
+	    (format "%.3f" y))
+	   ((< spacing 1)
+	    (format "%.2f" y))
+	   ((and (< spacing 1) (not (zerop (mod (* spacing 10) 1))))
+	    (format "%.1f" y))
+	   ((zerop (% spacing 1000000000))
+	    (format "%dG" (/ y 1000000000)))
+	   ((zerop (% spacing 1000000))
+	    (format "%dM" (/ y 1000000)))
+	   ((zerop (% spacing 1000))
+	    (format "%dk" (/ y 1000)))
+	   ((>= spacing 1)
+	    (format "%s" y))
+	   ((not whole)
+	    (format "%.1f" y))
+	   (t
+	    (format "%s" y)))))
+
+(defun eplot--format-value (value print-format label-format)
+  (replace-regexp-in-string
+   ;; Texts in SVG collapse multiple spaces into one.  So do it here,
+   ;; too, so that width calculations are correct.
+   " +" " "
+   (cond
+    ((eq print-format 'date)
+     (format-time-string
+      (or label-format "%Y-%m-%d") (eplot--days-to-time value)))
+    ((eq print-format 'year)
+     (format-time-string (or label-format "%Y") (eplot--days-to-time value)))
+    ((eq print-format 'time)
+     (format-time-string (or label-format "%H:%M:%S") value))
+    ((eq print-format 'minute)
+     (format-time-string (or label-format "%H:%M") value))
+    ((eq print-format 'hour)
+     (format-time-string (or label-format "%H") value))
+    (t
+     (format (or label-format "%s") value)))))
+
+(defun eplot--compute-x-ticks (xs x-values print-format x-label-format
+				  label-font label-font-size)
+  (let* ((min (seq-min x-values))
+	 (max (seq-max x-values))
+	 (count (length x-values))
+	 (max-print (eplot--format-value max print-format x-label-format))
+	 ;; We want each label to be spaced at least as long apart as
+	 ;; the length of the longest label, with room for two blanks
+	 ;; in between.
+	 (min-spacing (* 1.2 (eplot--text-width max-print label-font
+						label-font-size)))
+	 (digits (eplot--decimal-digits (- (cadr x-values) (car x-values))))
+	 (every (e/ 1 (expt 10 digits))))
+    (cond
+     ;; We have room for every X value.
+     ((< (* count min-spacing) xs)
+      (list every every))
+     ;; We have to prune X labels, but not grid lines.  (We shouldn't
+     ;; have a grid line more than every 10 pixels.)
+     ((< (* count 10) xs)
+      (list every
+	    (let ((label-step every))
+	      (while (> (/ (- max min) label-step) (/ xs min-spacing))
+		(setq label-step (eplot--next-weed label-step)))
+	      label-step)))
+     ;; We have to reduce both grid lines and labels.
+     (t
+      (let ((tick-step every))
+	(while (> (/ (- max min) tick-step) (/ xs 10))
+	  (setq tick-step (eplot--next-weed tick-step)))
+	(list tick-step
+	      (let ((label-step tick-step))
+		(while (> (/ (- max min) label-step) (/ xs min-spacing))
+		  (setq label-step (eplot--next-weed label-step))
+		  (while (not (zerop (% label-step tick-step)))
+		    (setq label-step (eplot--next-weed label-step))))
+		label-step)))))))
+
+(defun eplot--compute-y-ticks (ys y-values text-height)
+  (let* ((min (car y-values))
+	 (max (car (last y-values)))
+	 (count (length y-values))
+	 ;; We want each label to be spaced at least as long apart as
+	 ;; the height of the label.
+	 (min-spacing (+ text-height 10))
+	 (digits (eplot--decimal-digits (- (cadr y-values) (car y-values))))
+	 (every (e/ 1 (expt 10 digits))))
+    (cond
+     ;; We have room for every X value.
+     ((< (* count min-spacing) ys)
+      (list every every))
+     ;; We have to prune Y labels, but not grid lines.  (We shouldn't
+     ;; have a grid line more than every 10 pixels.)
+     ((< (* count 10) ys)
+      (list every
+	    (let ((label-step every))
+	      (while (> (/ (- max min) label-step) (/ ys min-spacing))
+		(setq label-step (eplot--next-weed label-step)))
+	      label-step)))
+     ;; We have to reduce both grid lines and labels.
+     (t
+      (let ((tick-step 1))
+	(while (> (/ count tick-step) (/ ys 10))
+	  (setq tick-step (eplot--next-weed tick-step)))
+	(list tick-step
+	      (let ((label-step tick-step))
+		(while (> (/ (- max min) label-step) (/ ys min-spacing))
+		  (setq label-step (eplot--next-weed label-step)))
+		label-step)))))))
+
+(defvar eplot--pleasing-numbers '(1 2 5 10))
+
+(defun eplot--next-weed (weed)
+  (let (digits series)
+    (if (>= weed 1)
+	(setq digits (truncate (log weed 10))
+	      series (/ weed (expt 10 digits)))
+      (setq digits (eplot--decimal-digits weed)
+	    series (truncate (* weed (expt 10 digits)))))
+    (let ((next (cadr (memq series eplot--pleasing-numbers))))
+      (unless next
+	(error "Invalid weed: %s" weed))
+      (if (>= weed 1)
+	  (* next (expt 10 digits))
+	(e/ next (expt 10 digits))))))
+
+(defun eplot--parse-gradient (string)
+  (when string
+    (let ((bits (split-string string)))
+      (list
+       (cons 'from (nth 0 bits))
+       (cons 'to (nth 1 bits))
+       (cons 'direction (intern (or (nth 2 bits) "top-down")))
+       (cons 'position (intern (or (nth 3 bits) "below")))))))
+
+(defun eplot--smooth (values algo xs)
+  (if (not algo)
+      values
+    (let* ((vals (cl-coerce values 'vector))
+	   (max (1- (length vals)))
+	   (period (* 4 (ceiling (/ max xs)))))
+      (cl-case algo
+	(moving-average
+	 (cl-loop for i from 0 upto max
+		  collect (e/ (cl-loop for ii from 0 upto (1- period)
+				       sum (elt vals (min (+ i ii) max)))
+			      period)))))))
+
+(defun eplot--vary-color (color n)
+  (let ((colors ["#e6194b" "#3cb44b" "#ffe119" "#4363d8" "#f58231" "#911eb4"
+		 "#46f0f0" "#f032e6" "#bcf60c" "#fabebe" "#008080" "#e6beff"
+		 "#9a6324" "#fffac8" "#800000" "#aaffc3" "#808000" "#ffd8b1"
+		 "#000075" "#808080" "#ffffff" "#000000"]))
+    (unless (equal color "vary")
+      (setq colors
+	    (if (string-search " " color)
+		(split-string color)
+	      (list color))))
+    (elt colors (mod n (length colors)))))
+
+(defun eplot--pv (plot slot &optional default)
+  (let ((user (cdr (assq slot eplot--user-defaults))))
+    (when (and (stringp user) (zerop (length user)))
+      (setq user nil))
+    (or user (slot-value plot slot) default)))
+
+(defun eplot--draw-plots (svg chart)
+  (if (eq (slot-value chart 'format) 'horizontal-bar-chart)
+      (eplot--draw-horizontal-bar-chart svg chart)
+    (eplot--draw-normal-plots svg chart)))
+    
+(defun eplot--draw-normal-plots (svg chart)
+  (with-slots ( plots chart-color height format
+		margin-bottom margin-left
+		min max xs ys
+		margin-top
+		x-values x-min x-max
+		label-font label-font-size)
+      chart
+    ;; Draw all the plots.
+    (cl-loop for plot in (reverse plots)
+	     for plot-number from 0
+	     for values = (slot-value plot 'values)
+	     for vals = (eplot--smooth
+			 (seq-map (lambda (v) (plist-get v :value)) values)
+			 (slot-value plot 'smoothing)
+			 xs)
+	     for polygon = nil
+	     for gradient = (eplot--parse-gradient (eplot--pv plot 'gradient))
+	     for lpy = nil
+	     for lpx = nil
+	     for style = (if (eq format 'bar-chart)
+			     'bar
+			   (slot-value plot 'style))
+	     for bar-max-width = (eplot--pv plot 'bar-max-width)
+	     for bar-width = (and (eq style 'bar)
+				  (min (or bar-max-width most-positive-fixnum)
+				       (/ xs (length x-values))))
+	     for bar-gap = (and (eq style 'bar)
+				(if (< bar-width
+				       (or bar-max-width most-positive-fixnum))
+				    (* bar-width 0.1)
+				  0))
+	     for clip-id = (format "url(#clip-%d)" plot-number)
+	     do
+	     (svg--append
+	      svg
+	      (dom-node 'clipPath
+			`((id . ,(format "clip-%d" plot-number)))
+			(dom-node 'rect
+				  `((x . ,margin-left)
+				    (y . , margin-top)
+				    (width . ,xs)
+				    (height . ,ys)))))
+	     (unless gradient
+	       (when-let ((fill (slot-value plot 'fill-color)))
+		 (setq gradient `((from . ,fill) (to . ,fill)
+				  (direction . top-down) (position . below)))))
+	     (when gradient
+	       (if (eq (eplot--vs 'position gradient) 'above)
+		   (push (cons margin-left margin-top) polygon)
+		 (push (cons margin-left (- height margin-bottom)) polygon)))
+	     (cl-loop
+	      for val in vals
+	      for value in values
+	      for x in x-values
+	      for i from 0
+	      for settings = (plist-get value :settings)
+	      for color = (eplot--vary-color
+			   (eplot--vs 'color settings (slot-value plot 'color))
+			   i)
+	      for py = (- (- height margin-bottom)
+			  (* (/ (- (* 1.0 val) min) (- max min))
+			     ys))
+	      for px = (if (eq style 'bar)
+			   (+ margin-left
+			      (/ (/ xs (length x-values)) 2)
+			      (* (e/ i (length x-values))
+				 xs))
+			 (+ margin-left
+			    (* (e/ (- x x-min) (- x-max x-min))
+			       xs)))
+	      do
+	      ;; Some data points may have texts.
+	      (when-let ((text (eplot--vs 'text settings)))
+		(svg-text svg text
+			  :font-family label-font
+			  :text-anchor "middle"
+			  :font-size label-font-size
+			  :font-weight 'normal
+			  :fill color
+			  :x px 
+			  :y (- py (eplot--text-height
+				    text label-font label-font-size)
+				-5)))
+	      ;; You may mark certain points.
+	      (when-let ((mark (eplot--vy 'mark settings)))
+		(cl-case mark
+		  (cross
+		   (let ((s (eplot--element-size val plot settings 3)))
+		     (svg-line svg (- px s) (- py s)
+			       (+ px s) (+ py s)
+			       :clip-path clip-id
+			       :stroke color)
+		     (svg-line svg (+ px s) (- py s)
+			       (- px s) (+ py s)
+			       :clip-path clip-id
+			       :stroke color)))
+		  (otherwise
+		   (svg-circle svg px py 3
+			       :fill color))))
+	      (cl-case style
+		(bar
+		 (if (not gradient)
+		     (svg-rectangle
+		      svg
+		      (+ (- px (e/ bar-width 2)) (e/ bar-gap 2))
+		      py
+		      (- bar-width bar-gap)
+		      (- height margin-bottom py)
+		      :clip-path clip-id
+		      :fill color)
+		   (let ((id (format "gradient-%s" (make-temp-name "grad"))))
+		     (eplot--gradient svg id 'linear
+				      (eplot--stops (eplot--vs 'from gradient)
+						    (eplot--vs 'to gradient))
+				      (eplot--vs 'direction gradient))
+		     (svg-rectangle
+		      svg
+		      (+ (- px (e/ bar-width 2)) (e/ bar-gap 2))
+		      py
+		      (- bar-width bar-gap)
+		      (- height margin-bottom py)
+		      :clip-path clip-id
+		      :gradient id))))
+		(impulse
+		 (let ((width (eplot--element-size val plot settings 1)))
+		   (if (= width 1)
+		       (svg-line svg
+				 px py
+				 px (- height margin-bottom)
+				 :clip-path clip-id
+				 :stroke color)
+		     (svg-rectangle svg
+				    (- px (e/ width 2)) py
+				    width (- height py margin-bottom)
+				    :clip-path clip-id
+				    :fill color))))
+		(point
+		 (svg-line svg px py (1+ px) (1+ py)
+			   :clip-path clip-id
+			   :stroke color))
+		(line
+		 ;; If we're doing a gradient, we're just collecting
+		 ;; points and will draw the polygon later.
+		 (if gradient
+		     (push (cons px py) polygon)
+		   (when lpx
+		     (svg-line svg lpx lpy px py
+			       :stroke-width (eplot--pv plot 'size 1)
+			       :clip-path clip-id
+			       :stroke color))))
+		(curve
+		 (push (cons px py) polygon))
+		(square
+		 (if gradient
+		     (progn
+		       (when lpx
+			 (push (cons lpx py) polygon))
+		       (push (cons px py) polygon))
+		   (when lpx
+		     (svg-line svg lpx lpy px lpy
+			       :clip-path clip-id
+			       :stroke color)
+		     (svg-line svg px lpy px py
+			       :clip-path clip-id
+			       :stroke color))))
+		(circle
+		 (svg-circle svg px py
+			     (eplot--element-size val plot settings 3)
+			     :clip-path clip-id
+			     :stroke color
+			     :fill (eplot--vary-color
+				    (eplot--vs
+				     'fill-color settings
+				     (or (slot-value plot 'fill-color) "none"))
+				    i)))
+		(cross
+		 (let ((s (eplot--element-size val plot settings 3)))
+		   (svg-line svg (- px s) (- py s)
+			     (+ px s) (+ py s)
+			     :clip-path clip-id
+			     :stroke color)
+		   (svg-line svg (+ px s) (- py s)
+			     (- px s) (+ py s)
+			     :clip-path clip-id
+			     :stroke color)))
+		(triangle
+		 (let ((s (eplot--element-size val plot settings 5)))
+		   (svg-polygon svg
+				(list
+				 (cons (- px (e/ s 2)) (+ py (e/ s 2)))
+				 (cons px (- py (e/ s 2)))
+				 (cons (+ px (e/ s 2)) (+ py (e/ s 2))))
+				:clip-path clip-id
+				:stroke color
+				:fill-color
+				(or (slot-value plot 'fill-color) "none"))))
+		(rectangle
+		 (let ((s (eplot--element-size val plot settings 3)))
+		   (svg-rectangle svg (- px (e/ s 2)) (- py (e/ s 2))
+				  s s
+				  :clip-path clip-id
+				  :stroke color
+				  :fill-color
+				  (or (slot-value plot 'fill-color) "none")))))
+	      (setq lpy py
+		    lpx px))
+
+	     ;; We're doing a gradient of some kind (or a curve), so
+	     ;; draw it now when we've collected the polygon.
+	     (when polygon
+	       ;; We have a "between" chart, so collect the data points
+	       ;; from the "extra" values, too.
+	       (when (memq 'two-values (slot-value plot 'data-format))
+		 (cl-loop
+		  for val in (nreverse
+			      (seq-map (lambda (v) (plist-get v :extra-value))
+				       values))
+		  for x from (1- (length vals)) downto 0
+		  for py = (- (- height margin-bottom)
+			      (* (/ (- (* 1.0 val) min) (- max min))
+				 ys))
+		  for px = (+ margin-left
+			      (* (e/ (- x x-min) (- x-max x-min))
+				 xs))
+		  do
+		  (cl-case style
+		    (line
+		     (push (cons px py) polygon))
+		    (square
+		     (when lpx
+		       (push (cons lpx py) polygon))
+		     (push (cons px py) polygon)))
+		  (setq lpx px lpy py)))
+	       (when gradient
+		 (if (eq (eplot--vs 'position gradient) 'above)
+		     (push (cons lpx margin-top) polygon)
+		   (push (cons lpx (- height margin-bottom)) polygon)))
+	       (let ((id (format "gradient-%d" plot-number)))
+		 (when gradient
+		   (eplot--gradient svg id 'linear
+				    (eplot--stops (eplot--vs 'from gradient)
+						  (eplot--vs 'to gradient))
+				    (eplot--vs 'direction gradient)))
+		 (if (eq style 'curve)
+		     (apply #'svg-path svg
+			    (nconc
+			     (cl-loop
+			      with points = (cl-coerce
+					     (nreverse polygon) 'vector)
+			      for i from 0 upto (1- (length points))
+			      collect
+			      (cond
+			       ((zerop i)
+				`(moveto ((,(car (elt points 0)) .
+					   ,(cdr (elt points 0))))))
+			       (t
+				`(curveto
+				  (,(eplot--bezier
+				     (eplot--pv plot 'bezier-factor)
+				     i points))))))
+			     (and gradient '((closepath))))
+			    `( :clip-path ,clip-id
+			       :stroke-width ,(eplot--pv plot 'size 1)
+			       :stroke ,(slot-value plot 'color)
+			       ,@(if gradient
+				     `(:gradient ,id)
+				   `(:fill "none"))))
+		   (svg-polygon
+		    svg (nreverse polygon)
+		    :clip-path clip-id
+		    :gradient id
+		    :stroke (slot-value plot 'fill-border-color))))))))
+
+(defun eplot--element-size (value plot settings default)
+  (eplot--vn 'size settings
+	     (if (slot-value plot 'size-factor)
+		 (* value (slot-value plot 'size-factor))
+	       (or (slot-value plot 'size) default))))
+
+(defun eplot--draw-horizontal-bar-chart (svg chart)
+  (with-slots ( plots chart-color height format
+		margin-bottom margin-left
+		min max xs ys
+		margin-top
+		x-values x-min x-max
+		label-font label-font-size label-color
+		horizontal-label-left horizontal-label-font-size)
+      chart
+    (dolist (plot plots)
+      (cl-loop with values = (slot-value plot 'values)
+	       with stride = (e/ ys (length values))
+	       with label-height = (eplot--text-height "xx" label-font
+						       label-font-size)
+	       with bar-gap = (* stride 0.1)
+	       for i from 0
+	       for value in values
+	       for settings = (plist-get value :settings)
+	       for bar-max-width = (eplot--pv plot 'bar-max-width)
+	       for py = (+ margin-top (* i stride))
+	       for px = (* (e/ (plist-get value :x) x-max) xs)
+	       for color = (eplot--vary-color
+			    (eplot--vs 'color settings (slot-value plot 'color))
+			    i)
+	       do
+	       (svg-rectangle svg
+			      margin-left
+			      (+ py (e/ bar-gap 2)
+				 (if (and bar-max-width
+					  (< bar-max-width (- stride bar-gap)))
+				     (- (/ stride 2) (/ bar-max-width 2))
+				   0))
+			      px
+			      (if bar-max-width
+				  (min bar-max-width (- stride bar-gap))
+				(- stride bar-gap))
+			      :fill color)
+	       (svg-text svg (eplot--vs 'label settings)
+			 :font-family label-font
+			 :text-anchor "left"
+			 :font-size horizontal-label-font-size
+			 :font-weight 'normal
+			 :fill label-color
+			 :x (or horizontal-label-left 5)
+			 :y (+ py label-height
+			       (/ stride 2)))))))
+
+(defun eplot--stops (from to)
+  (append `((0 . ,from))
+	  (cl-loop for (pct col) on (split-string to "-") by #'cddr
+		   collect (if col
+			       (cons (string-to-number pct) col)
+			     (cons 100 pct)))))
+
+(defun eplot--gradient (svg id type stops &optional direction)
+  "Add a gradient with ID to SVG.
+TYPE is `linear' or `radial'.
+
+STOPS is a list of percentage/color pairs.
+
+DIRECTION is one of `top-down', `bottom-up', `left-right' or `right-left'.
+nil means `top-down'."
+  (svg--def
+   svg
+   (apply
+    #'dom-node
+    (if (eq type 'linear)
+	'linearGradient
+      'radialGradient)
+    `((id . ,id)
+      (x1 . ,(if (eq direction 'left-right) 1 0))
+      (x2 . ,(if (eq direction 'right-left) 1 0))
+      (y1 . ,(if (eq direction 'bottom-up) 1 0))
+      (y2 . ,(if (eq direction 'top-down) 1 0)))
+    (mapcar
+     (lambda (stop)
+       (dom-node 'stop `((offset . ,(format "%s%%" (car stop)))
+			 (stop-color . ,(cdr stop)))))
+     stops))))
+
+(defun e% (num1 num2)
+  (let ((factor (max (expt 10 (eplot--decimal-digits num1))
+		     (expt 10 (eplot--decimal-digits num2)))))
+    (% (truncate (* num1 factor)) (truncate (* num2 factor)))))
+
+(defun eplot--decimal-digits (number)
+  (- (length (replace-regexp-in-string
+	      "0+\\'" ""
+	      (format "%.10f" (- number (truncate number)))))
+     2))
+
+(defun e/ (&rest numbers)
+  (if (cl-every #'integerp numbers)
+      (let ((int (apply #'/ numbers))
+	    (float (apply #'/ (* 1.0 (car numbers)) (cdr numbers))))
+	(if (= int float)
+	    int
+	  float))
+    (apply #'/ numbers)))
+
+(defun eplot--get-ticks (min max height &optional whole)
+  (let* ((diff (abs (- min max)))
+	 (even (eplot--pleasing-numbers (* (e/ diff height) 10)))
+	 (factor (max (expt 10 (eplot--decimal-digits even))
+		      (expt 10 (eplot--decimal-digits diff))))
+	 (fmin (truncate (* min factor)))
+	 (feven (truncate (* factor even)))
+	 start)
+    (when whole
+      (setq even 1
+	    feven factor))
+
+    (setq start
+	  (cond
+	   ((< min 0)
+	    (+ (floor fmin)
+	       feven
+	       (- (% (floor fmin) feven))
+	       (- feven)))
+	   (t
+	    (- fmin (% fmin feven)))))
+    (cl-loop for x from start upto (* max factor) by feven
+	     collect (e/ x factor))))
+
+(defun eplot--days-to-time (days)
+  (days-to-time (- days (time-to-days 0))))
+
+(defun eplot--get-date-ticks (start end xs label-font label-font-size
+				    x-label-format &optional skip-until)
+  (let* ((duration (- end start))
+	 (limits
+	  (list
+	   (list (/ 368 16) 'date
+		 (lambda (_d) t))
+	   (list (/ 368 4) 'date
+		 ;; Collect Mondays.
+		 (lambda (decoded)
+		   (= (decoded-time-weekday decoded) 1)))
+	   (list (/ 368 2) 'date
+		 ;; Collect 1st and 15th.
+		 (lambda (decoded)
+		   (or (= (decoded-time-day decoded) 1)
+		       (= (decoded-time-day decoded) 15))))
+	   (list (* 368 2) 'date
+		 ;; Collect 1st of every month.
+		 (lambda (decoded)
+		   (= (decoded-time-day decoded) 1)))
+	   (list (* 368 4) 'date
+		 ;; Collect every quarter.
+		 (lambda (decoded)
+		   (and (= (decoded-time-day decoded) 1)
+			(memq (decoded-time-month decoded) '(1 4 7 10)))))
+	   (list (* 368 8) 'date
+		 ;; Collect every half year.
+		 (lambda (decoded)
+		   (and (= (decoded-time-day decoded) 1)
+			(memq (decoded-time-month decoded) '(1 7)))))
+	   (list 1.0e+INF 'year
+		 ;; Collect every Jan 1st.
+		 (lambda (decoded)
+		   (and (= (decoded-time-day decoded) 1)
+			(= (decoded-time-month decoded) 1)))))))
+    ;; First we collect the potential ticks.
+    (while (or (>= duration (caar limits))
+	       (and skip-until (>= skip-until (caar limits))))
+      (pop limits))
+    (let* ((x-ticks (cl-loop for day from start upto end
+			     for time = (eplot--days-to-time day)
+			     for decoded = (decode-time time)
+			     when (funcall (nth 2 (car limits)) decoded)
+			     collect day))
+	   (count (length x-ticks))
+	   (print-format (nth 1 (car limits)))
+	   (max-print (eplot--format-value (car x-ticks) print-format
+					   x-label-format))
+	   (min-spacing (* 1.2 (eplot--text-width max-print label-font
+						  label-font-size))))
+      (cond
+       ;; We have room for every X value.
+       ((< (* count min-spacing) xs)
+	(list x-ticks print-format))
+       ;; We have to prune X labels, but not grid lines.  (We shouldn't
+       ;; have a grid line more than every 10 pixels.)
+       ((< (* count 10) xs)
+	(cond
+	 ((not (cdr limits))
+	  (eplot--year-ticks
+	   x-ticks xs label-font label-font-size x-label-format))
+	 ;; The Mondays grid is special, because it doesn't resolve
+	 ;; into any of the bigger limits evenly.
+	 ((= (caar limits) (/ 368 4))
+	  (let* ((max-print (eplot--format-value
+			     (car x-ticks) print-format x-label-format))
+		 (min-spacing (* 1.2 (eplot--text-width
+				      max-print label-font label-font-size)))
+		 (weed-factor 2))
+	    (while (> (* (/ (length x-ticks) weed-factor) min-spacing) xs)
+	      (setq weed-factor (* weed-factor 2)))
+	    (list x-ticks 'date
+		  (cl-loop for val in x-ticks
+			   for i from 0
+			   collect (list val t (zerop (% i weed-factor)))))))
+	 (t
+	  (pop limits)
+	  (catch 'found
+	    (while limits
+	      (let ((candidate
+		     (cl-loop for day in x-ticks
+			      for time = (eplot--days-to-time day)
+			      for decoded = (decode-time time)
+			      collect (list day t
+					    (not (not
+						  (funcall (nth 2 (car limits))
+							   decoded)))))))
+		(setq print-format (nth 1 (car limits)))
+		(let* ((max-print (eplot--format-value
+				   (car x-ticks) print-format x-label-format))
+		       (min-spacing (* 1.2 (eplot--text-width
+					    max-print label-font
+					    label-font-size)))
+		       (num-labels (seq-count (lambda (v) (nth 2 v))
+					      candidate)))
+		  (when (and (not (zerop num-labels))
+			     (< (* num-labels min-spacing) xs))
+		    (throw 'found (list x-ticks print-format candidate)))))
+	      (pop limits))
+	    (eplot--year-ticks
+	     x-ticks xs label-font label-font-size x-label-format)))))
+       ;; We have to reduce both grid lines and labels.
+       (t
+	(eplot--get-date-ticks start end xs label-font label-font-size
+			       x-label-format (caar limits)))))))
+
+(defun eplot--year-ticks (x-ticks xs label-font label-font-size x-label-format)
+  (let* ((year-ticks (mapcar (lambda (day)
+			       (decoded-time-year
+				(decode-time (eplot--days-to-time day))))
+			     x-ticks))
+	 (xv (eplot--compute-x-ticks
+	      xs year-ticks 'year x-label-format label-font label-font-size)))
+    (let ((tick-step (car xv))
+	  (label-step (cadr xv)))
+      (list x-ticks 'year
+	    (cl-loop for year in year-ticks
+		     for val in x-ticks
+		     collect (list val
+				   (zerop (% year tick-step))
+				   (zerop (% year label-step))))))))
+
+(defun eplot--get-time-ticks (start end xs label-font label-font-size
+				    x-label-format
+				    &optional skip-until)
+  (let* ((duration (- end start))
+	 (limits
+	  (list
+	   (list (* 2 60) 'time
+		 (lambda (_d) t))
+	   (list (* 2 60 60) 'time
+		 ;; Collect whole minutes.
+		 (lambda (decoded)
+		   (zerop (decoded-time-second decoded))))
+	   (list (* 3 60 60) 'minute
+		 ;; Collect five minutes.
+		 (lambda (decoded)
+		   (zerop (% (decoded-time-minute decoded) 5))))
+	   (list (* 4 60 60) 'minute
+		 ;; Collect fifteen minutes.
+		 (lambda (decoded)
+		   (and (zerop (decoded-time-second decoded))
+			(memq (decoded-time-minute decoded) '(0 15 30 45)))))
+	   (list (* 8 60 60) 'minute
+		 ;; Collect half hours.
+		 (lambda (decoded)
+		   (and (zerop (decoded-time-second decoded))
+			(memq (decoded-time-minute decoded) '(0 30)))))
+	   (list 1.0e+INF 'hour
+		 ;; Collect whole hours.
+		 (lambda (decoded)
+		   (and (zerop (decoded-time-second decoded))
+			(zerop (decoded-time-minute decoded))))))))
+    ;; First we collect the potential ticks.
+    (while (or (>= duration (caar limits))
+	       (and skip-until (>= skip-until (caar limits))))
+      (pop limits))
+    (let* ((x-ticks (cl-loop for time from start upto end
+			     for decoded = (decode-time time)
+			     when (funcall (nth 2 (car limits)) decoded)
+			     collect time))
+	   (count (length x-ticks))
+	   (print-format (nth 1 (car limits)))
+	   (max-print (eplot--format-value (car x-ticks) print-format
+					   x-label-format))
+	   (min-spacing (* (+ (length max-print) 2) (e/ label-font-size 2))))
+      (cond
+       ;; We have room for every X value.
+       ((< (* count min-spacing) xs)
+	(list x-ticks print-format))
+       ;; We have to prune X labels, but not grid lines.  (We shouldn't
+       ;; have a grid line more than every 10 pixels.)
+       ;; If we're plotting just seconds, then just weed out some seconds.
+       ((and (< (* count 10) xs)
+	     (= (caar limits) (* 2 60)))
+	(let ((xv (eplot--compute-x-ticks
+		   xs x-ticks 'time x-label-format label-font label-font-size)))
+	  (let ((tick-step (car xv))
+		(label-step (cadr xv)))
+	    (list x-ticks 'time
+		  (cl-loop for val in x-ticks
+			   collect (list val
+					 (zerop (% val tick-step))
+					 (zerop (% val label-step))))))))
+       ;; Normal case for pruning labels, but not grid lines.
+       ((< (* count 10) xs)
+	(if (not (cdr limits))
+	    (eplot--hour-ticks x-ticks xs label-font label-font-size
+			       x-label-format)
+	  (pop limits)
+	  (catch 'found
+	    (while limits
+	      (let ((candidate
+		     (cl-loop for val in x-ticks
+			      for decoded = (decode-time val)
+			      collect (list val t
+					    (not (not
+						  (funcall (nth 2 (car limits))
+							   decoded)))))))
+		(setq print-format (nth 1 (car limits)))
+		(let ((min-spacing (* (+ (length max-print) 2)
+				      (e/ label-font-size 2))))
+		  (when (< (* (seq-count (lambda (v) (nth 2 v)) candidate)
+			      min-spacing)
+			   xs)
+		    (throw 'found (list x-ticks print-format candidate)))))
+	      (pop limits))
+	    (eplot--hour-ticks x-ticks xs label-font label-font-size
+			       x-label-format))))
+       ;; We have to reduce both grid lines and labels.
+       (t
+	(eplot--get-time-ticks start end xs label-font label-font-size
+			       x-label-format (caar limits)))))))
+
+(defun eplot--hour-ticks (x-ticks xs label-font label-font-size
+				  x-label-format)
+  (let* ((eplot--pleasing-numbers '(1 3 6 12))
+	 (hour-ticks (mapcar (lambda (time)
+			       (decoded-time-hour (decode-time time)))
+			     x-ticks))
+	 (xv (eplot--compute-x-ticks
+	      xs hour-ticks 'year x-label-format label-font label-font-size)))
+    (let ((tick-step (car xv))
+	  (label-step (cadr xv)))
+      (list x-ticks 'hour
+	    (cl-loop for hour in hour-ticks
+		     for val in x-ticks
+		     collect (list val
+				   (zerop (% hour tick-step))
+				   (zerop (% hour label-step))))))))
+
+(defun eplot--int (number)
+  (cond
+   ((integerp number)
+    number)
+   ((= number (truncate number))
+    (truncate number))
+   (t
+    number)))
+
+(defun eplot--pleasing-numbers (number)
+  (let* ((digits (eplot--decimal-digits number))
+	 (one (e/ 1 (expt 10 digits)))
+	 (two (e/ 2 (expt 10 digits)))
+	 (five (e/ 5 (expt 10 digits))))
+    (catch 'found
+      (while t
+	(when (< number one)
+	  (throw 'found one))
+	(setq one (* one 10))
+	(when (< number two)
+	  (throw 'found two))
+	(setq two (* two 10))
+	(when (< number five)
+	  (throw 'found five))
+	(setq five (* five 10))))))
+
+(defun eplot-parse-and-insert (file)
+  "Parse and insert a file in the current buffer."
+  (interactive "fEplot file: ")
+  (let ((default-directory (file-name-directory file)))
+    (setq-local eplot--current-chart
+		(eplot--render (with-temp-buffer
+				 (insert-file-contents file)
+				 (eplot--parse-buffer))))))
+
+(defun eplot-list-chart-headers ()
+  "Pop to a buffer showing all chart parameters."
+  (interactive)
+  (pop-to-buffer "*eplot help*")
+  (let ((inhibit-read-only t))
+    (special-mode)
+    (erase-buffer)
+    (insert "The following headers influence the overall\nlook of the chart:\n\n")
+    (eplot--list-headers eplot--chart-headers)
+    (ensure-empty-lines 2)
+    (insert "The following headers are per plot:\n\n")
+    (eplot--list-headers eplot--plot-headers)
+    (goto-char (point-min))))
+
+(defun eplot--list-headers (headers)
+  (dolist (header (sort (copy-sequence headers)
+			(lambda (e1 e2)
+			  (string< (car e1) (car e2)))))
+    (insert (propertize (capitalize (symbol-name (car header))) 'face 'bold)
+	    "\n")
+    (let ((start (point)))
+      (insert (plist-get (cdr header) :doc) "\n")
+      (when-let ((valid (plist-get (cdr header) :valid)))
+	(insert "Possible values are: "
+		(mapconcat (lambda (v) (format "`%s'" v)) valid ", ")
+		".\n"))
+      (indent-rigidly start (point) 2))
+    (ensure-empty-lines 1)))
+
+(defvar eplot--transients
+  '((("Size"
+      ("sw" "Width")
+      ("sh" "Height")
+      ("sl" "Margin-Left")
+      ("st" "Margin-Top")
+      ("sr" "Margin-Right")
+      ("sb" "Margin-Bottom"))
+     ("Colors"
+      ("ca" "Axes-Color")
+      ("cb" "Border-Color")
+      ("cc" "Chart-Color")
+      ("cf" "Frame-Color")
+      ("cs" "Surround-Color")
+      ("ct" "Title-Color"))
+     ("Background"
+      ("bc" "Background-Color")
+      ("bg" "Background-Gradient")
+      ("bi" "Background-Image-File")
+      ("bv" "Background-Image-Cover")
+      ("bo" "Background-Image-Opacity")))
+    (("General"
+      ("gt" "Title")
+      ("gf" "Font")
+      ("gs" "Font-Size")
+      ("ge" "Font-Weight")
+      ("go" "Format")
+      ("gw" "Frame-Width")
+      ("gh" "Header-File")
+      ("gi" "Min")
+      ("ga" "Max")
+      ("gm" "Mode")
+      ("gr" "Reset" eplot--reset-transient)
+      ("gv" "Save" eplot--save-transient))
+     ("Axes, Grid & Legend"
+      ("xx" "X-Title")
+      ("xy" "Y-Title")
+      ("xf" "Label-Font")
+      ("xz" "Label-Font-Size")
+      ("xs" "X-Axis-Title-Space")
+      ("xl" "X-Label-Format")
+      ("xa" "Y-Label-Format")
+      ("il" "Grid-Color")
+      ("io" "Grid-Opacity")
+      ("ip" "Grid-Position")
+      ("ll" "Legend")
+      ("lb" "Legend-Background-Color")
+      ("lo" "Legend-Border-Color")
+      ("lc" "Legend-Color"))
+     ("Plot"
+      ("ps" "Style")
+      ("pc" "Color")
+      ("po" "Data-Column")
+      ("pr" "Data-format")
+      ("pn" "Fill-Border-Color")
+      ("pi" "Fill-Color")
+      ("pg" "Gradient")
+      ("pz" "Size")
+      ("pm" "Smoothing")
+      ("pb" "Bezier-Factor")))))
+
+(defun eplot--define-transients ()
+  (cl-loop for row in eplot--transients
+	   collect (cl-coerce
+		    (cl-loop for column in row
+			     collect
+			     (cl-coerce
+			      (cons (pop column)
+				    (mapcar #'eplot--define-transient column))
+			      'vector))
+		    'vector)))
+
+(defun eplot--define-transient (action)
+  (list (nth 0 action)
+	(nth 1 action)
+	;; Allow explicit commands.
+	(or (nth 2 action)
+	    ;; Make a command for altering a setting.
+	    (lambda ()
+	      (interactive)
+	      (eplot--execute-transient (nth 1 action))))))
+
+(defun eplot--execute-transient (action)
+  (with-current-buffer (or eplot--data-buffer (current-buffer))
+    (unless eplot--transient-settings
+      (setq-local eplot--transient-settings nil))
+    (let* ((name (intern (downcase action)))
+	   (spec (assq name (append eplot--chart-headers eplot--plot-headers)))
+	   (type (plist-get (cdr spec) :type)))
+      ;; Sanity check.
+      (unless spec
+	(error "No such header type: %s" name))
+      (setq eplot--transient-settings
+	    (append
+	     eplot--transient-settings
+	     (list
+	      (cons
+	       name
+	       (cond
+		((eq type 'number)
+		 (read-number (format "Value for %s (%s): " action type)))
+		((string-match "color" (downcase action))
+		 (eplot--read-color (format "Value for %s (color): " action)))
+		((string-match "font" (downcase action))
+		 (eplot--read-font-family
+		  (format "Value for %s (font family): " action)))
+		((string-match "gradient" (downcase action))
+		 (eplot--read-gradient action))
+		((string-match "file" (downcase action))
+		 (read-file-name (format "File for %s: " action)))
+		((eq type 'symbol)
+		 (intern
+		  (completing-read (format "Value for %s: " action)
+				   (plist-get (cdr spec) :valid)
+				   nil t)))
+		(t
+		 (read-string (format "Value for %s (string): " action))))))))
+      (eplot-update-view-buffer))))
+
+(defun eplot--read-gradient (action)
+  (format "%s %s %s %s"
+	  (eplot--read-color (format "%s from color: " action))
+	  (eplot--read-color (format "%s to color: " action))
+	  (completing-read (format "%s direction: " action)
+			   '(top-down bottom-up left-right right-left)
+			   nil t)
+	  (completing-read (format "%s position: " action)
+			   '(below above)
+			   nil t)))
+
+(defun eplot--reset-transient ()
+  (interactive)
+  (with-current-buffer (or eplot--data-buffer (current-buffer))
+    (setq-local eplot--transient-settings nil)
+    (eplot-update-view-buffer)))
+
+(defun eplot--save-transient (file)
+  (interactive "FSave parameters to file: ")
+  (when (and (file-exists-p file)
+	     (not (yes-or-no-p "File exists; overwrite? ")))
+    (user-error "Exiting"))
+  (let ((settings (with-current-buffer (or eplot--data-buffer (current-buffer))
+		    eplot--transient-settings)))
+    (with-temp-buffer
+      (cl-loop for (name . value) in settings
+	       do (insert (capitalize (symbol-name name)) ": "
+			  (format "%s" value) "\n"))
+      (write-region (point-min) (point-max) file))))
+
+(defvar-keymap eplot-control-mode-map
+  "RET" #'eplot-control-update
+  "TAB" #'eplot-control-next-field
+  "C-<tab>" #'eplot-control-next-field
+  "<backtab>" #'eplot-control-prev-field)
+
+(define-derived-mode eplot-control-mode special-mode "eplot control"
+  (setq-local completion-at-point-functions
+	      (cons 'eplot--complete-control completion-at-point-functions))
+  (add-hook 'before-change-functions #'eplot--process-text-input-before nil t)
+  (add-hook 'after-change-functions #'eplot--process-text-value nil t)
+  (add-hook 'after-change-functions #'eplot--process-text-input nil t)
+  (setq-local nobreak-char-display nil)
+  (setq truncate-lines t))
+
+(defun eplot--complete-control ()
+  ;; Complete headers names.
+  (when-let* ((input (get-text-property (point) 'input))
+	      (name (plist-get input :name))
+	      (spec (cdr (assq name (append eplot--plot-headers
+					    eplot--chart-headers))))
+	      (start (plist-get input :start))
+	      (end (- (plist-get input :end) 2))
+	      (completion-ignore-case t))
+    (skip-chars-backward " " start)
+    (or
+     (and (eq (plist-get spec :type) 'symbol)
+	  (lambda ()
+	    (let ((valid (plist-get spec :valid)))
+	      (completion-in-region
+	       (save-excursion
+		 (skip-chars-backward "^ " start)
+		 (point))
+	       end
+	       (mapcar #'symbol-name valid))
+	      'completion-attempted)))
+     (and (string-match "color" (symbol-name name))
+	  (lambda ()
+	    (completion-in-region
+	     (save-excursion
+	       (skip-chars-backward "^ " start)
+	       (point))
+	     end eplot--colors)
+	    'completion-attempted))
+     (and (string-match "\\bfile\\b" (symbol-name name))
+	  (lambda ()
+	    (completion-in-region
+	     (save-excursion
+	       (skip-chars-backward "^ " start)
+	       (point))
+	     end (directory-files "."))
+	    'completion-attempted))
+     (and (string-match "\\bfont\\b" (symbol-name name))
+	  (lambda ()
+	    (completion-in-region
+	     (save-excursion
+	       (skip-chars-backward "^ " start)
+	       (point))
+	     end
+	     (eplot--font-families))
+	    'completion-attempted)))))
+
+(defun eplot--read-font-family (prompt)
+  "Prompt for a font family, possibly offering autocomplete."
+  (let ((families (eplot--font-families)))
+    (if families
+	(completing-read prompt families)
+      (read-string prompt))))
+
+(defun eplot--font-families ()
+  (when (executable-find "fc-list")
+    (let ((fonts nil))
+      (with-temp-buffer
+	(call-process "fc-list" nil t nil ":" "family")
+	(goto-char (point-min))
+	(while (re-search-forward "^\\([^,\n]+\\)" nil t)
+	  (push (downcase (match-string 1)) fonts)))
+      (seq-uniq (sort fonts #'string<)))))
+
+(defun eplot-control-next-input ()
+  "Go to the next input field."
+  (interactive)
+  (when-let ((match (text-property-search-forward 'input)))
+    (goto-char (prop-match-beginning match))))
+
+(defun eplot-control-update ()
+  "Update the chart based on the current settings."
+  (interactive)
+  (let ((settings nil))
+    (save-excursion
+      (goto-char (point-min))
+      (while-let ((match (text-property-search-forward 'input)))
+	(when (equal (get-text-property (prop-match-beginning match) 'face)
+		     'eplot--input-changed)
+	  (let* ((name (plist-get (prop-match-value match) :name))
+		 (spec (cdr (assq name (append eplot--plot-headers
+					       eplot--chart-headers))))
+		 (value
+		  (or (plist-get (prop-match-value match) :value)
+		      (plist-get (prop-match-value match) :original-value))))
+	    (setq value (string-trim (string-replace "\u00A0" " " value)))
+	    (push (cons name
+			(cl-case (plist-get spec :type)
+			  (number
+			   (string-to-number value))
+			  (symbol
+			   (intern (downcase value)))
+			  (symbol-list
+			   (mapcar #'intern (split-string (downcase value))))
+			  (t
+			   value)))
+		  settings)))))
+    (with-current-buffer eplot--data-buffer
+      (setq-local eplot--transient-settings (nreverse settings))
+      (eplot-update-view-buffer))))
+
+(defvar eplot--column-width nil)
+
+(defun eplot-create-controls ()
+  "Pop to a buffer that lists all parameters and allows editing."
+  (interactive)
+  (with-current-buffer (or eplot--data-buffer (current-buffer))
+    (let ((settings eplot--transient-settings)
+	  (data-buffer (current-buffer))
+	  (chart eplot--current-chart)
+	  ;; Find the max width of all the different names.
+	  (width (seq-max
+		  (mapcar (lambda (e)
+			    (length (cadr e)))
+			  (apply #'append
+				 (mapcar #'cdr
+					 (apply #'append eplot--transients))))))
+	  (transients (mapcar #'copy-sequence
+			      (copy-sequence eplot--transients))))
+      (unless chart
+	(user-error "Must be called from an eplot buffer that has rendered a chart"))
+      ;; Rearrange the transients a bit for better display.
+      (let ((size (caar transients)))
+	(setcar (car transients) (caadr transients))
+	(setcar (cadr transients) size))
+      (pop-to-buffer "*eplot controls*")
+      (unless (eq major-mode 'eplot-control-mode)
+	(eplot-control-mode))
+      (setq-local eplot--data-buffer data-buffer
+		  eplot--column-width (+ width 12 2))
+      (let ((inhibit-read-only t)
+	    (before-change-functions nil)
+	    (after-change-functions nil))
+	(erase-buffer)
+	(cl-loop for column in transients
+		 for cn from 0
+		 do
+		 (goto-char (point-min))
+		 (end-of-line)
+		 (cl-loop
+		  for row in column
+		  do
+		  (if (zerop cn)
+		      (when (not (bobp))
+			(insert (format (format "%%-%ds" (+ width 14)) "")
+				"\n"))
+		    (unless (= (count-lines (point-min) (point)) 1)
+		      (if (eobp)
+			  (progn
+			    (insert (format (format "%%-%ds" (+ width 14)) "")
+				    "\n")
+			    (insert (format (format "%%-%ds" (+ width 14)) "")
+				    "\n")
+			    (forward-line -1)
+			    (end-of-line))
+			(forward-line 1)
+			(end-of-line))))
+		  ;; If we have a too-long input in the first column,
+		  ;; then go to the next line.
+		  (when (and (> cn 0)
+			     (> (- (point) (pos-bol))
+				(+ width 12 2)))
+		    (forward-line 1)
+		    (end-of-line))
+		  (insert (format (format "%%-%ds" (+ width 14))
+				  (propertize (pop row) 'face 'bold)))
+		  (if (looking-at "\n")
+		      (forward-line 1)				
+		    (insert "\n"))
+		  (cl-loop
+		   for elem in row
+		   for name = (cadr elem)
+		   for slot = (intern (downcase name))
+		   when (null (nth 2 elem))
+		   do
+		   (let* ((object (if (assq slot eplot--chart-headers)
+				      chart
+				    (car (slot-value chart 'plots))))
+			  (value (format "%s"
+					 (or (cdr (assq slot settings))
+					     (if (not (slot-boundp object slot))
+						 ""
+					       (or (slot-value object slot)
+						   ""))))))
+		     (end-of-line)
+		     ;; If we have a too-long input in the first column,
+		     ;; then go to the next line.
+		     (when (and (> cn 0)
+				(> (- (point) (pos-bol))
+				   (+ width 12 2)))
+		       (forward-line 1)
+		       (end-of-line))
+		     (when (and (> cn 0)
+				(bolp))
+		       (insert (format (format "%%-%ds" (+ width 14)) "") "\n")
+		       (forward-line -1)
+		       (end-of-line))
+		     (insert (format (format "%%-%ds" (1+ width)) name))
+		     (eplot--input slot value
+				   (if (cdr (assq slot settings))
+				       'eplot--input-changed
+				     'eplot--input-default))
+		     (if (looking-at "\n")
+			 (forward-line 1)				
+		       (insert "\n")))))))
+      (goto-char (point-min)))))
+
+(defface eplot--input-default
+  '((t :background "#505050"
+       :foreground "#a0a0a0"
+       :box (:line-width 1)))
+  "Face for eplot default inputs.")
+
+(defface eplot--input-changed
+  '((t :background "#505050"
+       :foreground "white"
+       :box (:line-width 1)))
+  "Face for eplot changed inputs.")
+
+(defvar-keymap eplot--input-map
+  :full t :parent text-mode-map
+  "RET" #'eplot-control-update
+  "TAB" #'eplot-input-complete
+  "C-a" #'eplot-move-beginning-of-input
+  "C-e" #'eplot-move-end-of-input
+  "C-k" #'eplot-kill-input
+  "C-<tab>" #'eplot-control-next-field
+  "<backtab>" #'eplot-control-prev-field)
+
+(defun eplot-input-complete ()
+  "Complete values in inputs."
+  (interactive)
+  (cond
+   ((let ((completion-fail-discreetly t))
+      (completion-at-point))
+    ;; Completion was performed; nothing else to do.
+    nil)
+   ((not (get-text-property (point) 'input))
+    (eplot-control-next-input))
+   (t
+    (user-error "No completion in this field"))))
+
+(defun eplot-move-beginning-of-input ()
+  "Move to the start of the current input field."
+  (interactive)
+  (if (= (point) (eplot--beginning-of-field))
+      (goto-char (pos-bol))
+    (goto-char (eplot--beginning-of-field))))
+  
+(defun eplot-move-end-of-input ()
+  "Move to the end of the current input field."
+  (interactive)
+  (let ((input (get-text-property (point) 'input)))
+    (if (or (not input)
+	    (= (point) (1- (plist-get input :end))))
+	(goto-char (pos-eol))
+      (goto-char (1+ (eplot--end-of-field))))))
+
+(defun eplot-control-next-field ()
+  "Move to the beginning of the next field."
+  (interactive)
+  (let ((input (get-text-property (point) 'input))
+	(start (point)))
+    (when input
+      (goto-char (plist-get input :end)))
+    (let ((match (text-property-search-forward 'input)))
+      (if match
+	  (goto-char (prop-match-beginning match))
+	(goto-char start)
+	(user-error "No next field")))))
+
+(defun eplot-control-prev-field ()
+  "Move to the beginning of the previous field."
+  (interactive)
+  (let ((input (get-text-property (point) 'input))
+	(start (point)))
+    (when input
+      (goto-char (plist-get input :start))
+      (unless (bobp)
+	(forward-char -1)))
+    (let ((match (text-property-search-backward 'input)))
+      (unless match
+	(goto-char start)
+	(user-error "No previous field")))))
+
+(defun eplot-kill-input ()
+  "Remove the part of the input after point."
+  (interactive)
+  (let ((end (1+ (eplot--end-of-field))))
+    (kill-new (string-trim (buffer-substring (point) end)))
+    (delete-region (point) end)))
+
+(defun eplot--input (name value face)
+  (let ((start (point))
+	input)
+    (insert value)
+    (when (< (length value) 11)
+      (insert (make-string (- 11 (length value)) ?\u00A0)))
+    (put-text-property start (point) 'face face)
+    (put-text-property start (point) 'inhibit-read-only t)
+    (put-text-property start (point) 'input
+		       (setq input
+			     (list :name name
+				   :size 11
+				   :is-default (eq face 'eplot--input-default)
+				   :original-value value
+				   :original-face face
+				   :start (set-marker (make-marker) start)
+				   :value value)))
+    (put-text-property start (point) 'local-map eplot--input-map)
+    ;; This seems like a NOOP, but redoing the properties like this
+    ;; somehow makes `delete-region' work better.
+    (set-text-properties start (point) (text-properties-at start))
+    (insert (propertize " " 'face face
+			'input input
+			'inhibit-read-only t
+			'local-map eplot--input-map))
+    (plist-put input :end (point-marker))
+    (insert " ")))
+
+(defun eplot--end-of-field ()
+  (- (plist-get (get-text-property (point) 'input) :end) 2))
+
+(defun eplot--beginning-of-field ()
+  (plist-get (get-text-property (point) 'input) :start))
+
+(defvar eplot--prev-deletion nil)
+
+(defun eplot--process-text-input-before (beg end)
+  (message "Before: %s %s" beg end)
+  (cond
+   ((= beg end)
+    (setq eplot--prev-deletion nil))
+   ((> end beg)
+    (setq eplot--prev-deletion (buffer-substring beg end)))))
+
+(defun eplot--process-text-input (beg end _replace-length)
+  ;;(message "After: %s %s %s %s" beg end replace-length eplot--prev-deletion)
+  (when-let ((props (if eplot--prev-deletion
+ 			(text-properties-at 0 eplot--prev-deletion)
+ 		      (if (get-text-property end 'input)
+ 			  (text-properties-at end)
+ 			(text-properties-at beg))))
+ 	     (input (plist-get props 'input)))
+    ;; The action concerns something in the input field.
+    (let ((buffer-undo-list t)
+	  (inhibit-read-only t)
+	  (size (plist-get input :size)))
+      (save-excursion
+	(set-text-properties beg (- (plist-get input :end) 2) props)
+	(goto-char (1- (plist-get input :end)))
+	(let* ((remains (- (point) (plist-get input :start) 1))
+	       (trim (- size remains 1)))
+	  (if (< remains size)
+	      ;; We need to add some padding.
+	      (insert (apply #'propertize (make-string trim ?\u00A0)
+			     props))
+	    ;; We need to delete some padding, but only delete
+	    ;; spaces at the end.
+	    (setq trim (abs trim))
+	    (while (and (> trim 0)
+			(eql (char-after (1- (point))) ?\u00A0))
+	      (delete-region (1- (point)) (point))
+	      (cl-decf trim))
+	    (when (> trim 0)
+	      (eplot--possibly-open-column)))))
+      ;; We re-set the properties so that they are continguous.  This
+      ;; somehow makes the machinery that decides whether we can kill
+      ;; a word work better.
+      (set-text-properties (plist-get input :start)
+			   (1- (plist-get input :end)) props)
+      ;; Compute what the value is now.
+      (let ((value (buffer-substring-no-properties
+		    (plist-get input :start)
+		    (plist-get input :end))))
+	(when (string-match "\u00A0+\\'" value)
+	  (setq value (substring value 0 (match-beginning 0))))
+	(plist-put input :value value)))))
+
+(defun eplot--possibly-open-column ()
+  (save-excursion
+    (when-let ((input (get-text-property (point) 'input)))
+      (goto-char (plist-get input :end)))
+    (unless (looking-at " *\n")
+      (skip-chars-forward " ")
+      (while (not (eobp))
+	(let ((text (buffer-substring (point) (pos-eol))))
+	  (delete-region (point) (pos-eol))
+	  (forward-line 1)
+	  (if (eobp)
+	      (insert (make-string eplot--column-width ?\s) text "\n")
+	    (forward-char eplot--column-width)
+	    (if (get-text-property (point) 'input)
+		(forward-line 1)
+	      (insert text)
+	      ;; We have to fix up the markers.
+	      (save-excursion
+		(let* ((match (text-property-search-backward 'input))
+		       (input (prop-match-value match)))
+		  (plist-put input :start
+			     (set-marker (plist-get input :start)
+					 (prop-match-beginning match)))
+		  (plist-put input :end
+			     (set-marker (plist-get input :end)
+					 (+ (prop-match-end match) 1))))))))))))
+
+(defun eplot--process-text-value (beg _end _replace-length)
+  (when-let* ((input (get-text-property beg 'input)))
+    (let ((inhibit-read-only t))
+      (when (plist-get input :is-default)
+	(put-text-property (plist-get input :start)
+			   (plist-get input :end)
+			   'face
+			   (if (equal (plist-get input :original-value)
+				      (plist-get input :value))
+			       'eplot--input-default
+			     'eplot--input-changed))))))
+
+(defun eplot--read-color (prompt)
+  "Read an SVG color."
+  (completing-read prompt eplot--colors))
+
+(eval `(transient-define-prefix eplot-customize ()
+	 "Customize Chart"
+	 ,@(eplot--define-transients)))
+
+(defun eplot--bezier (factor i points)
+  (cl-labels ((padd (p1 p2)
+		(cons (+ (car p1) (car p2)) (+ (cdr p1) (cdr p2))))
+	      (psub (p1 p2)
+		(cons (- (car p1) (car p2)) (- (cdr p1) (cdr p2))))
+	      (pscale (factor point)
+		(cons (* factor (car point)) (* factor (cdr point)))))
+    (let* ((start (elt points (1- i)))
+	   (end (elt points i))
+	   (prev (if (< (- i 2) 0)
+		     start
+		   (elt points (- i 2))))
+	   (next (if (> (1+ i) (1- (length points)))
+		     end
+		   (elt points (1+ i))))
+	   (start-control-point
+	    (padd start (pscale factor (psub end prev))))
+	   (end-control-point
+	    (padd end (pscale factor (psub start next)))))
+      (list (car start-control-point)
+	    (cdr start-control-point)
+	    (car end-control-point)
+	    (cdr end-control-point)
+	    (car end)
+	    (cdr end)))))
+
+;;; CSV Parsing Stuff.
+
+(defun eplot--csv-buffer-p ()
+  (save-excursion
+    (goto-char (point-min))
+    (let ((min 1.0e+INF)
+	  (max -1.0e+INF)
+	  (total 0)
+	  (lines 0))
+      (while (not (eobp))
+	(let ((this 0))
+	  (while (search-forward "," (pos-eol) t)
+	    (cl-incf total)
+	    (cl-incf this))
+	  (forward-line 1)
+	  (cl-incf lines)
+	  (setq min (min min this)
+		max (max max this))))
+      (let ((mid (e/ total lines)))
+	;; If we have a comma on each line, and it's fairly evenly
+	;; distributed, it's a CSV buffer.
+	(and (>= min 1)
+	     (< (* mid 0.9) min)
+	     (> (* mid 1.1) max))))))
+
+(defun eplot--numericalp (value)
+  (string-match-p "\\`[-.0-9]*\\'" value))
+
+(defun eplot--numberish (value)
+  (if (or (zerop (length value))
+	  (not (eplot--numericalp value)))
+      value
+    (string-to-number value)))
+
+(defun eplot--parse-csv-buffer ()
+  (unless (fboundp 'pcsv-parse-buffer)
+    (user-error "You need to install the pcsv package to parse CSV files"))
+  (let ((csv (and (fboundp 'pcsv-parse-buffer)
+		  ;; This repeated check is just to silence the byte
+		  ;; compiler.
+		  (pcsv-parse-buffer)))
+	names)
+    ;; Check whether the first line looks like a header.
+    (when (and (length> csv 1)
+	       ;; The second line is all numbers...
+	       (cl-every #'eplot--numericalp (nth 1 csv))
+	       ;; .. and the first line isn't.
+	       (not (cl-every #'eplot--numericalp (nth 0 csv))))
+      (setq names (pop csv)))
+    (list
+     (cons 'legend (and names "true"))
+     (cons :plots
+	   (cl-loop
+	    for column from 1 upto (1- (length (car csv)))
+	    collect
+	    (list (cons :headers
+			(list
+			 (cons 'name (elt names column))
+			 (cons 'data-format
+			       (cond
+				((cl-every (lambda (e) (<= (length e) 4))
+					   (mapcar #'car csv))
+				 "year")
+				((cl-every (lambda (e) (= (length e) 8))
+					   (mapcar #'car csv))
+				 "date")
+				(t
+				 "number")))
+			 (cons 'color (eplot--vary-color "vary" (1- column)))))
+		  (cons
+		   :values
+		   (cl-loop for line in csv
+			    collect (list :x (eplot--numberish (car line))
+					  :value (eplot--numberish
+						  (elt line column)))))))))))
+
+(declare-function org-element-parse-buffer "org-element")
+
+(defun eplot--parse-org-buffer ()
+  (require 'org-element)
+  (let* ((table (nth 2 (nth 2 (org-element-parse-buffer))))
+	 (columns (cl-loop for cell in (nthcdr 2 (nth 2 table))
+			   collect (substring-no-properties (nth 2 cell))))
+	 (value-column (or (seq-position columns "value") 0))
+	 (date-column (seq-position columns "date")))
+    `((:plots
+       ((:headers
+	 ,@(and date-column '((data-format . "date"))))
+	(:values 
+	 ,@(cl-loop for row in (nthcdr 4 table)
+		    collect
+		    (let ((cells (cl-loop for cell in (nthcdr 2 row)
+					  collect (substring-no-properties
+						   (nth 2 cell)))))
+		      (list :value (string-to-number (elt cells value-column))
+			    :x (string-to-number
+				(replace-regexp-in-string
+				 "[^0-9]" "" (elt cells date-column)))
+			    )))))))))
+
+(provide 'eplot)
+
+;;; eplot.el ends here