844 lines
29 KiB
EmacsLisp
844 lines
29 KiB
EmacsLisp
;;; chartg.el --- Google charts (and maybe other)
|
|
;;
|
|
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
|
|
;; Created: 2008-04-06 Sun
|
|
(defconst chart:version "0.2") ;; Version:
|
|
;; Last-Updated:
|
|
;; URL:
|
|
;; Keywords:
|
|
;; Compatibility:
|
|
;;
|
|
;; Features that might be required by this library:
|
|
;;
|
|
;; None
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Change log:
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; This program is free software; you can redistribute it and/or
|
|
;; modify it under the terms of the GNU General Public License as
|
|
;; published by the Free Software Foundation; either version 2, or
|
|
;; (at your option) any later version.
|
|
;;
|
|
;; This program is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
;; General Public License for more details.
|
|
;;
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with this program; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
;; Floor, Boston, MA 02110-1301, USA.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Code:
|
|
|
|
(eval-when-compile (require 'cl))
|
|
|
|
(defconst chartg-types
|
|
'((line-chartg-x lc)
|
|
(line-chartg-xy lxy)
|
|
(line-chart ls)
|
|
|
|
(bar-chartg-horizontal bhs)
|
|
(bar-chartg-vertical bvs)
|
|
(bar-chartg-horizontal-grouped bhg)
|
|
(bar-chartg-vertical-grouped bvg)
|
|
|
|
(pie-2-dimensional p)
|
|
(pie-3-dimensional p3)
|
|
|
|
(venn-diagram v)
|
|
(scatter-plot s)
|
|
|
|
(radar-chart r)
|
|
(radar-chartg-w-splines rs)
|
|
|
|
(geographical-map t)
|
|
(meter gom)))
|
|
|
|
(defconst chartg-types-keywords
|
|
(mapcar (lambda (rec)
|
|
(symbol-name (car rec)))
|
|
chartg-types))
|
|
|
|
(defvar chartg-mode-keywords-and-states
|
|
'(("Output-file:" (accept file-name))
|
|
("Size:" (accept number))
|
|
("Data:" (accept number))
|
|
("Type:" (accept chartg-type))
|
|
))
|
|
|
|
(defvar chartg-mode-keywords
|
|
(mapcar (lambda (rec)
|
|
(car rec))
|
|
chartg-mode-keywords-and-states))
|
|
|
|
;; Fix-me: I started to implement a parser, but I think I will drop it
|
|
;; and wait for Semantic to be easily available instead. Or just use
|
|
;; Calc/Org Tables.
|
|
|
|
(defvar chartg-intermediate-states
|
|
'((end-or-label (or end-of-file label))
|
|
))
|
|
|
|
(defvar chartg-extra-keywords-and-states
|
|
'(
|
|
;;("Provider:")
|
|
("Colors:")
|
|
("Solid-fill:")
|
|
("Linear-gradient:")
|
|
("Linear-stripes:")
|
|
("Chartg-title:" (and string end-or-label))
|
|
("Legends:" (accept string))
|
|
("Axis-types:")
|
|
("Axis-labels:")
|
|
("Axis-ranges:")
|
|
("Axis-styles:")
|
|
("Bar-thickness:")
|
|
("Bar-chartg-zero-line:")
|
|
("Bar-chartg-zero-line-2:")
|
|
("Line-styles-1:")
|
|
("Line-styles-2:")
|
|
("Grid-lines:")
|
|
("Shape-markers:")
|
|
("Range-markers:")
|
|
))
|
|
|
|
(defvar chartg-extra-keywords
|
|
(mapcar (lambda (rec)
|
|
(car rec))
|
|
chartg-extra-keywords-and-states))
|
|
|
|
(defvar chartg-raw-keywords-and-states
|
|
'(
|
|
("Google-chartg-raw:" (accept string))
|
|
))
|
|
|
|
(defvar chartg-raw-keywords
|
|
(mapcar (lambda (rec)
|
|
(car rec))
|
|
chartg-raw-keywords-and-states))
|
|
|
|
(defvar chartg-mode-keywords-re (regexp-opt chartg-mode-keywords))
|
|
(defvar chartg-extra-keywords-re (regexp-opt chartg-extra-keywords))
|
|
(defvar chartg-types-keywords-re (regexp-opt chartg-types-keywords))
|
|
(defvar chartg-raw-keywords-re (regexp-opt chartg-raw-keywords))
|
|
|
|
(defvar chartg-font-lock-keywords
|
|
`((,chartg-mode-keywords-re . font-lock-keyword-face)
|
|
(,chartg-extra-keywords-re . font-lock-variable-name-face)
|
|
(,chartg-types-keywords-re . font-lock-function-name-face)
|
|
(,chartg-raw-keywords-re . font-lock-preprocessor-face)
|
|
))
|
|
|
|
(defvar chartg-font-lock-defaults
|
|
'(chartg-font-lock-keywords nil t))
|
|
|
|
(defvar chartg-mode-syntax-table
|
|
(let ((table (make-syntax-table)))
|
|
(modify-syntax-entry ?\n "> " table)
|
|
(modify-syntax-entry ?\; "< " table)
|
|
table))
|
|
|
|
(defun chartg-create (provider out-file size data type
|
|
title legends &optional extras)
|
|
"Create a chart image.
|
|
PROVIDER is what to use for creating the chart. Currently only
|
|
`google' for Google's chart API is supported.
|
|
|
|
OUT-FILE is where the image goes.
|
|
|
|
SIZE is a cons cell with pixel width and height.
|
|
|
|
DATA is the data to draw the chart from. It is a list of data
|
|
sets where each data set has the form:
|
|
|
|
(list (list NUMBERS ...) (MIN . MAX)))
|
|
|
|
TYPE can be the following:
|
|
|
|
* Line charts
|
|
|
|
- lc: Line chart with only y values. Each dataset is a new
|
|
line.
|
|
|
|
- lxy: Line chart with both x and y values. For each line there
|
|
should be a pair of datasets, the first for x and the second
|
|
for y. If the x dataset just contains a single -1 then values
|
|
are evenly spaced along the x-axis.
|
|
|
|
- ls: Like above, but axis are not drawn.
|
|
|
|
* Bar charts:
|
|
|
|
- bhs: horizontal bars.
|
|
- bvs: vertical bars.
|
|
- bhg, bvg: dito grouped.
|
|
|
|
* Pie charts:
|
|
|
|
- cht=p: one dimensional
|
|
- cht=p3: three dimensional
|
|
|
|
* Venn diagrams
|
|
|
|
- cht=v: data should be specified as
|
|
* the first three values specify the relative sizes of three
|
|
circles, A, B, and C
|
|
* the fourth value specifies the area of A intersecting B
|
|
* the fifth value specifies the area of A intersecting C
|
|
* the sixth value specifies the area of B intersecting C
|
|
* the seventh value specifies the area of A intersecting B
|
|
intersecting C
|
|
|
|
* Scatter plots
|
|
|
|
- cht=s: Supply a pair of datasets, first for x and second for
|
|
y coordinates.
|
|
|
|
* Radar charts
|
|
|
|
- cht=r: straight lines.
|
|
- cht=rs: splines.
|
|
|
|
You will have to find out the format of the datasets
|
|
yourself, I don't understand it ;-)
|
|
|
|
Or perhaps mail google?
|
|
|
|
* Maps
|
|
|
|
- cht=t
|
|
|
|
together with
|
|
|
|
- chtm=AREA: AREA for provider `google' is currently one of
|
|
* africa
|
|
* asia
|
|
* europe
|
|
* middle_east
|
|
* south_america
|
|
* usa
|
|
* world
|
|
|
|
* Meter
|
|
|
|
- cht=gom: A speed meter type meter. Takes a single value.
|
|
|
|
TITLE is a string to use as title.
|
|
|
|
LEGENDS is a list of labels to put on the data.
|
|
|
|
EXTRAS is a list of extra arguments with the form
|
|
|
|
(EXTRA-TYPE EXTRA-VALUE)
|
|
|
|
Where EXTRA-TYPE is the extra argument type and EXTRA-VALUE the
|
|
value. The following EXTRA-TYPEs are supported:
|
|
|
|
* COLORS: value is a list of colors corresponding to the list of
|
|
DATA. Each color have the format RRGGBB or RRGGBBTT where the
|
|
first form is the normal way to specify colors in rgb-format
|
|
and the second has an additional TT for transparence. TT=00
|
|
means completely transparent and TT=FF means completely opaque.
|
|
|
|
FILL-AREA are fill colors for data sets in line charts. It should
|
|
be a list
|
|
|
|
(list COLOR START-INDEX END-INDEX)
|
|
|
|
"
|
|
(message "(chartg-create %s %s %s %s %s %s %s" provider out-file size data type
|
|
title legends)
|
|
(unless (symbolp type)
|
|
(error "Argument TYPE should be a symbol"))
|
|
(unless (assoc type chartg-types)
|
|
(error "Unknown chart type: %s" type))
|
|
(cond
|
|
((eq provider 'google)
|
|
(let* ((g-type (nth 1 (assoc type chartg-types)))
|
|
(width (car size))
|
|
(height (cdr size))
|
|
;;(size-par (format "&chs=%sx%s" width height))
|
|
;;
|
|
numbers
|
|
scales
|
|
colors-par
|
|
;;
|
|
url
|
|
content
|
|
)
|
|
(setq url
|
|
(format
|
|
"http://chart.apis.google.com/chart?cht=%s&chs=%dx%d" g-type width height))
|
|
;;(setq url (concat url size-par))
|
|
;; Data and scales
|
|
(unless data
|
|
(error "No data"))
|
|
(dolist (rec data)
|
|
(let* ((rec-numbers (car rec))
|
|
(number-str
|
|
(let (str)
|
|
(dolist (num rec-numbers)
|
|
(setq str
|
|
(if (not str)
|
|
(number-to-string num)
|
|
(concat str "," (number-to-string num)))))
|
|
str))
|
|
(rec-scale (cadr rec))
|
|
(rec-min (car rec-scale))
|
|
(rec-max (cdr rec-scale))
|
|
(scale-str (when rec-scale (format "%s,%s" rec-min rec-max)))
|
|
)
|
|
(if (not numbers)
|
|
(progn
|
|
(setq numbers (concat "&chd=t:" number-str))
|
|
(when (or scale-str
|
|
(memq g-type '(p p3 gom)))
|
|
(setq scales (concat "&chds=" scale-str))))
|
|
(setq numbers (concat numbers "|" number-str))
|
|
(when scale-str
|
|
(setq scales (concat scales "," scale-str))))))
|
|
(setq url (concat url numbers))
|
|
(when scales (setq url (concat url scales)))
|
|
;; fix-me: encode the url
|
|
(when title (setq url (concat url "&chtt=" (url-hexify-string title))))
|
|
(when legends
|
|
(let ((url-legends (mapconcat 'url-hexify-string legends "|"))
|
|
(arg (if (memq g-type '(p p3 gom))
|
|
"&chl="
|
|
"&chdl=")))
|
|
(setq url (concat url arg url-legends))))
|
|
(dolist (extra extras)
|
|
(let ((extra-type (car extra))
|
|
(extra-value (cdr extra)))
|
|
(cond
|
|
((eq extra-type 'GOOGLE-RAW)
|
|
(setq url (concat url extra-value)))
|
|
((eq extra-type 'colors)
|
|
;; Colors
|
|
(dolist (color extra-value)
|
|
(if (not colors-par)
|
|
(setq colors-par (concat "&chco=" color))
|
|
(setq colors-par (concat colors-par "," color))))
|
|
(when colors-par (setq url (concat url colors-par))))
|
|
(t (error "Unsupported extra type: %s" extra-type)))))
|
|
|
|
;;(lwarn t :warning "url=%s" url)(top-level)
|
|
;;(setq url (concat url "&chxt=y"))
|
|
(message "Sending %s" url)
|
|
(setq content
|
|
(with-current-buffer (url-retrieve-synchronously url)
|
|
(goto-char (point-min))
|
|
(if (search-forward "\n\n" nil t)
|
|
(buffer-substring-no-properties (point) (point-max))
|
|
(view-buffer-other-window (current-buffer))
|
|
(error "Bad content"))))
|
|
(let* ((is-html (string-match-p "</body></html>" content))
|
|
(fname (progn
|
|
(when is-html
|
|
(setq out-file (concat (file-name-sans-extension out-file) ".html")))
|
|
(expand-file-name out-file)
|
|
))
|
|
(do-it (or (not (file-exists-p fname))
|
|
(y-or-n-p
|
|
(concat "File " fname " exists. Replace it? "))))
|
|
(buf (find-buffer-visiting fname))
|
|
(this-window (selected-window)))
|
|
(when do-it
|
|
(when buf (kill-buffer buf))
|
|
(with-temp-file fname
|
|
(insert content))
|
|
(if (not is-html)
|
|
(view-file-other-window fname)
|
|
(chartg-show-last-error-file fname))
|
|
(select-window this-window)))))
|
|
(t (error "Unknown provider: %s" provider)))
|
|
)
|
|
|
|
(defun chartg-show-last-error-file (fname)
|
|
(interactive)
|
|
(with-output-to-temp-buffer (help-buffer)
|
|
(help-setup-xref (list #'chartg-show-last-error-file fname) (interactive-p))
|
|
(with-current-buffer (help-buffer)
|
|
(insert "Error, see ")
|
|
(insert-text-button "result error page"
|
|
'action
|
|
`(lambda (btn)
|
|
(browse-url ,fname))))))
|
|
|
|
(defvar chartg-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map [(meta tab)] 'chartg-complete)
|
|
(define-key map [(control ?c) (control ?c)] 'chartg-make-chart)
|
|
map))
|
|
|
|
(defun chartg-missing-keywords ()
|
|
(let ((collection (copy-sequence chartg-mode-keywords)))
|
|
(save-excursion
|
|
(save-restriction
|
|
(widen)
|
|
(goto-char (point-min))
|
|
(while (re-search-forward chartg-mode-keywords-re nil t)
|
|
(setq collection
|
|
(delete (match-string-no-properties 0)
|
|
collection)))))
|
|
collection))
|
|
|
|
;;;###autoload
|
|
(defun chartg-complete ()
|
|
(interactive)
|
|
(let* ((here (point))
|
|
(partial (when (looking-back (rx word-start
|
|
(optional ?\")
|
|
(0+ (any "[a-z]"))))
|
|
(match-string-no-properties 0)))
|
|
(part-pos (if partial
|
|
(match-beginning 0)
|
|
(setq partial "")
|
|
(point)))
|
|
(state (catch 'pos-state (chartg-get-state (point))))
|
|
(msg "No completions")
|
|
collection
|
|
all
|
|
prompt
|
|
res)
|
|
(when state
|
|
(cond
|
|
((or (= (current-column) 0)
|
|
(equal state 'need-label))
|
|
(setq collection (append (chartg-missing-keywords)
|
|
chartg-extra-keywords
|
|
chartg-raw-keywords
|
|
nil))
|
|
(setq prompt "Label: "))
|
|
((equal state '(accept number))
|
|
(setq res nil)
|
|
(setq msg (propertize "Needs a number here!"
|
|
'face 'secondary-selection)))
|
|
((equal state '(accept chartg-type))
|
|
(setq collection chartg-types-keywords)
|
|
(setq prompt "Chart type: "))
|
|
((equal state '(accept file-name))
|
|
(setq res
|
|
(concat "\"" (read-file-name "Output-file: "
|
|
nil
|
|
;; fix-me: handle partial
|
|
partial)
|
|
"\""))))
|
|
(when collection
|
|
(let ((all (if partial
|
|
(all-completions partial collection)
|
|
collection)))
|
|
(setq res (when all
|
|
(if (= (length all) 1)
|
|
(car all)
|
|
(completing-read prompt collection nil t partial)))))))
|
|
(if (not res)
|
|
(message "%s" msg)
|
|
(insert (substring res (length partial))))))
|
|
|
|
|
|
(defun chartg-get-state (want-pos-state)
|
|
(let* (par-output-file
|
|
par-provider
|
|
par-size
|
|
par-data par-data-temp
|
|
par-data-min par-data-max
|
|
par-type
|
|
par-title
|
|
par-legends
|
|
par-google-raw
|
|
(here (point))
|
|
token-before-pos
|
|
pos-state
|
|
(state 'need-label)
|
|
(problems
|
|
(catch 'problems
|
|
(save-restriction
|
|
;;(widen)
|
|
(if want-pos-state
|
|
(unless (re-search-backward chartg-mode-keywords-re nil t)
|
|
(goto-char (point-min)))
|
|
(goto-char (point-min)))
|
|
(let (this-keyword
|
|
this-start
|
|
this-end
|
|
params
|
|
token
|
|
token-pos
|
|
next-token
|
|
found-labels
|
|
current-label)
|
|
(while (or token
|
|
(progn
|
|
(setq pos-state state)
|
|
(setq token-before-pos (point))
|
|
(condition-case err
|
|
(setq token (read (current-buffer)))
|
|
(error
|
|
(if (eq (car err) 'end-of-file)
|
|
(unless (or (eq state 'need-label)
|
|
(member '(quote |) state))
|
|
(throw 'problems (format "Unexpected end, state=%s" state)))
|
|
(throw 'problems
|
|
(error-message-string err)))))))
|
|
(message "token=%s, label=%s, state=%s" token current-label state)
|
|
(when (and want-pos-state
|
|
(>= (point) want-pos-state))
|
|
(when (= (point) want-pos-state)
|
|
;; right after item
|
|
(setq pos-state nil))
|
|
(goto-char here)
|
|
(throw 'pos-state pos-state))
|
|
(when (and (listp state) (memq 'number state))
|
|
(unless (numberp token)
|
|
(save-match-data
|
|
(let ((token-str (format "%s" token)))
|
|
(setq token-str (replace-regexp-in-string "\\([0-9]\\),\\([0-9]\\)" "\\1\\2" token-str))
|
|
(when (string-match-p "^[0-9]+$" token-str)
|
|
(setq token (string-to-number token-str)))))))
|
|
(cond ;; state
|
|
;; Label
|
|
((eq state 'need-label)
|
|
(unless (symbolp token)
|
|
(throw 'problems (format "Expected label, got %s" token)))
|
|
(unless (member (symbol-name token)
|
|
(append chartg-mode-keywords
|
|
chartg-extra-keywords
|
|
chartg-raw-keywords
|
|
nil))
|
|
(throw 'problems (format "Unknown label %s" token)))
|
|
(when (member (symbol-name token) found-labels)
|
|
(throw 'problems (format "Label %s defined twice" token)))
|
|
(setq current-label token)
|
|
(setq found-labels (cons current-label found-labels))
|
|
(setq token nil)
|
|
;;(setq state 'need-value)
|
|
(case current-label
|
|
('Output-file:
|
|
(setq state '(accept file-name)))
|
|
('Size:
|
|
(setq state '(accept number)))
|
|
('Data:
|
|
(setq state '(accept number)))
|
|
('Type:
|
|
(setq state '(accept chartg-type)))
|
|
('Chartg-title:
|
|
(setq state '(accept string)))
|
|
('Legends:
|
|
(setq state '(accept string)))
|
|
('Google-chartg-raw:
|
|
(setq state '(accept string)))
|
|
))
|
|
;;;; Values
|
|
;; Alt
|
|
((equal state '(accept '| symbol))
|
|
(if (eq '| token)
|
|
(case current-label
|
|
('Legends:
|
|
(setq token nil)
|
|
(setq state '(accept string)))
|
|
(t (error "internal error, current-label=%s, state=%s" current-label state)))
|
|
(if (symbolp token)
|
|
(progn
|
|
;;(setq token nil)
|
|
(setq state 'need-label))
|
|
(throw 'problems (format "Expected | or label, got %s" token)))))
|
|
;; Strings
|
|
((equal state '(accept string))
|
|
(unless (stringp token)
|
|
(throw 'problems "Expected string"))
|
|
(case current-label
|
|
('Chartg-title:
|
|
(setq par-title token)
|
|
(setq token nil)
|
|
(setq state 'need-label))
|
|
('Legends:
|
|
(setq par-legends (cons token par-legends))
|
|
(setq token nil)
|
|
(setq state '(accept '| symbol)))
|
|
('Google-chartg-raw:
|
|
(setq par-google-raw token)
|
|
(setq token nil)
|
|
(setq state 'need-label))
|
|
(t (error "internal error, current-label=%s, state=%s" current-label state))))
|
|
;; Output file
|
|
((equal state '(accept file-name))
|
|
(unless (stringp token)
|
|
(throw 'problems "Expected file name string"))
|
|
(assert (eq current-label 'Output-file:))
|
|
(setq par-output-file token)
|
|
(setq token nil)
|
|
(setq state 'need-label))
|
|
;; Numbers
|
|
((equal state '(accept number))
|
|
(unless (numberp token)
|
|
(throw 'problems "Expected number"))
|
|
(case current-label
|
|
('Size:
|
|
(if (not par-size)
|
|
(progn
|
|
(setq par-size token)
|
|
(setq token nil)
|
|
(setq state '(accept number 'x 'X)))
|
|
(setq par-size (cons par-size token))
|
|
(setq token nil)
|
|
(setq state 'need-label)))
|
|
('Data:
|
|
;;(assert (not par-data-temp))
|
|
(setq par-data-temp (cons token par-data-temp))
|
|
(setq par-data-min token)
|
|
(setq par-data-max token)
|
|
(setq token nil)
|
|
(setq state '(accept number ', '| symbol))
|
|
)
|
|
(t (error "internal error, state=%s, current-label=%s" state current-label)))
|
|
)
|
|
;; Numbers or |
|
|
((equal state '(accept number ', '| symbol))
|
|
(if (numberp token)
|
|
(progn
|
|
(setq par-data-min (if par-data-min (min par-data-min token) token))
|
|
(setq par-data-max (if par-data-max (max par-data-max token) token))
|
|
(setq par-data-temp (cons token par-data-temp))
|
|
(message "par-data-min/max=%s/%s, token=%s -- %s" par-data-min par-data-max token par-data-temp)
|
|
(setq token nil))
|
|
(if (eq ', token)
|
|
(setq token nil)
|
|
(if (or (eq '| token)
|
|
(symbolp token))
|
|
(progn
|
|
(unless par-data-temp
|
|
(throw 'problems "Empty data set"))
|
|
(setq par-data (cons (list (reverse par-data-temp) (cons par-data-min par-data-max)) par-data))
|
|
(setq par-data-temp nil)
|
|
(setq par-data-min nil)
|
|
(setq par-data-max nil)
|
|
(if (not (eq '| token))
|
|
(setq state 'need-label)
|
|
(setq state '(accept number))
|
|
(setq token nil)))
|
|
(throw 'problems "Expected | or EOF")
|
|
))))
|
|
;; Numbers or x/X
|
|
((equal state '(accept number 'x 'X))
|
|
(assert (eq current-label 'Size:))
|
|
(let ((is-n (numberp token))
|
|
(is-x (memq token '(x X))))
|
|
(unless (or is-n is-x)
|
|
(throw 'problems "Expected X or number"))
|
|
(if is-x
|
|
(progn
|
|
(setq token nil)
|
|
(setq state '(accept number)))
|
|
(setq par-size (cons par-size token))
|
|
(setq token nil)
|
|
(setq state 'need-label))))
|
|
;; Chart type
|
|
((equal state '(accept chartg-type))
|
|
(setq par-type token)
|
|
(unless (assoc par-type chartg-types)
|
|
(throw 'problems (format "Unknown chart type: %s" par-type)))
|
|
(setq token nil)
|
|
(setq state 'need-label))
|
|
(t (error "internal error, state=%s" state))))))
|
|
;; fix-me here
|
|
|
|
nil)))
|
|
(when want-pos-state
|
|
(goto-char here)
|
|
(throw 'pos-state state))
|
|
(unless problems
|
|
(let ((missing-lab (chartg-missing-keywords)))
|
|
(when missing-lab
|
|
(setq problems (format "Missing required labels: %s" missing-lab)))))
|
|
(if problems
|
|
(let ((msg (if (listp problems)
|
|
(nth 1 problems)
|
|
problems))
|
|
(where (if (listp problems)
|
|
(nth 0 problems)
|
|
token-before-pos)))
|
|
(goto-char where)
|
|
(skip-chars-forward " \t")
|
|
(error msg))
|
|
(goto-char here)
|
|
;;(defun chartg-create (out-file provider size data type &rest extras)
|
|
(setq par-provider 'google)
|
|
(setq par-legends (nreverse par-legends))
|
|
(let ((extras nil))
|
|
(when par-google-raw
|
|
(setq extras (cons (cons 'GOOGLE-RAW par-google-raw) extras)))
|
|
(chartg-create par-provider par-output-file par-size
|
|
par-data par-type par-title par-legends extras))
|
|
nil)))
|
|
|
|
;;;###autoload
|
|
(defun chartg-make-chart ()
|
|
"Try to make a new chart.
|
|
If region is active then make a new chart from data in the
|
|
selected region.
|
|
|
|
Else if current buffer is in `chartg-mode' then do it from the
|
|
chart specifications in this buffer. Otherwise create a new
|
|
buffer and initialize it with `chartg-mode'.
|
|
|
|
If the chart specifications are complete enough to make a chart
|
|
then do it and show the resulting chart image. If not then tell
|
|
user what is missing.
|
|
|
|
NOTE: This is beta, no alpha code. It is not ready.
|
|
|
|
Below are some examples. To test them mark an example and do
|
|
|
|
M-x chartg-make-chart
|
|
|
|
* Example, simple x-y chart:
|
|
|
|
Output-file: \"~/temp-chart.png\"
|
|
Size: 200 200
|
|
Data: 3 8 5 | 10 20 30
|
|
Type: line-chartg-xy
|
|
|
|
* Example, pie:
|
|
|
|
Output-file: \"~/temp-depression.png\"
|
|
Size: 400 200
|
|
Data:
|
|
2,160,000
|
|
3,110,000
|
|
1,510,000
|
|
73,600
|
|
775,000
|
|
726,000
|
|
8,180,000
|
|
419,000
|
|
Type: pie-3-dimensional
|
|
Chartg-title: \"Depression hits on Google\"
|
|
Legends:
|
|
\"SSRI\"
|
|
| \"Psychotherapy\"
|
|
| \"CBT\"
|
|
| \"IPT\"
|
|
| \"Psychoanalysis\"
|
|
| \"Mindfulness\"
|
|
| \"Meditation\"
|
|
| \"Exercise\"
|
|
|
|
|
|
* Example, pie:
|
|
|
|
Output-file: \"~/temp-panic.png\"
|
|
Size: 400 200
|
|
Data:
|
|
979,000
|
|
969,000
|
|
500,000
|
|
71,900
|
|
193,000
|
|
154,000
|
|
2,500,000
|
|
9,310,000
|
|
Type: pie-3-dimensional
|
|
Chartg-title: \"Depression hits on Google\"
|
|
Legends:
|
|
\"SSRI\"
|
|
| \"Psychotherapy\"
|
|
| \"CBT\"
|
|
| \"IPT\"
|
|
| \"Psychoanalysis\"
|
|
| \"Mindfulness\"
|
|
| \"Meditation\"
|
|
| \"Exercise\"
|
|
|
|
|
|
* Example using raw:
|
|
|
|
Output-file: \"~/temp-chartg-slipsen-kostar.png\"
|
|
Size: 400 130
|
|
Data: 300 1000 30000
|
|
Type: bar-chartg-horizontal
|
|
Chartg-title: \"Vad killen i slips tjänar jämfört med dig och mig\"
|
|
Google-chartg-raw: \"&chds=0,30000&chco=00cd00|ff4500|483d8b&chxt=y,x&chxl=0:|Killen+i+slips|Partiledarna|Du+och+jag&chf=bg,s,ffd700\"
|
|
|
|
|
|
"
|
|
(interactive)
|
|
(if mark-active
|
|
(let* ((rb (region-beginning))
|
|
(re (region-end))
|
|
(data (buffer-substring-no-properties rb re))
|
|
(buf (generate-new-buffer "*Chart from region*")))
|
|
(switch-to-buffer buf)
|
|
(insert data)
|
|
(chartg-mode))
|
|
(unless (eq major-mode 'chartg-mode)
|
|
(switch-to-buffer (generate-new-buffer "*Chart*"))
|
|
(chartg-mode)))
|
|
(chartg-get-state nil))
|
|
|
|
;; (defun chartg-from-region (min max)
|
|
;; "Try to make a new chart from data in selected region.
|
|
;; See `chartg-mode' for examples you can test with this function."
|
|
;; (interactive "r")
|
|
;; (unless mark-active (error "No region selected"))
|
|
;; (let* ((rb (region-beginning))
|
|
;; (re (region-end))
|
|
;; (data (buffer-substring-no-properties rb re))
|
|
;; (buf (generate-new-buffer "*Chart from region*")))
|
|
;; (switch-to-buffer buf)
|
|
;; (insert data)
|
|
;; (chartg-mode)
|
|
;; (chartg-get-state nil)))
|
|
|
|
(define-derived-mode chartg-mode fundamental-mode "Chart"
|
|
"Mode for specifying charts.
|
|
\\{chartg-mode-map}
|
|
|
|
To make a chart see `chartg-make-chart'.
|
|
|
|
"
|
|
(set (make-local-variable 'font-lock-defaults) chartg-font-lock-defaults)
|
|
(set (make-local-variable 'comment-start) ";")
|
|
;; Look within the line for a ; following an even number of backslashes
|
|
;; after either a non-backslash or the line beginning.
|
|
(set (make-local-variable 'comment-start-skip)
|
|
"\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+ *")
|
|
;; Font lock mode uses this only when it KNOWS a comment is starting.
|
|
(set (make-local-variable 'font-lock-comment-start-skip) ";+ *")
|
|
(set (make-local-variable 'comment-add) 1) ;default to `;;' in comment-region
|
|
(set (make-local-variable 'comment-column) 40)
|
|
;; Don't get confused by `;' in doc strings when paragraph-filling.
|
|
(set (make-local-variable 'comment-use-global-state) t)
|
|
(set-syntax-table chartg-mode-syntax-table)
|
|
(when (looking-at (rx buffer-start (0+ whitespace) buffer-end))
|
|
(insert ";; Type C-c C-c to make a chart, M-Tab to complete\n"))
|
|
(let ((missing (chartg-missing-keywords)))
|
|
(when missing
|
|
(save-excursion
|
|
(goto-char (point-max))
|
|
(dolist (miss missing)
|
|
(insert "\n" miss " "))))))
|
|
|
|
;; Tests
|
|
;;(chartg-create 'google "temp.png" '(200 . 150) '(((90 70) . nil)) 'pie-3-dimensional "test title" nil '((colors "FFFFFF" "00FF00")))
|
|
|
|
;; Fix-me
|
|
(add-to-list 'auto-mode-alist '("\\.mx-chart\\'" . chartg-mode))
|
|
|
|
(provide 'chartg)
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; chartg.el ends here
|