;; processing-mode.el
;; Processing.org language based on Java mode. Adds keyword
;; highlighting for all recognized Processing language functions.
;; Allows compilation of buffers and "sketches" from within Emacs but
;; only for more recent versions of Processing.
;; Copyright (C) 2008, 2009 Rudolf Olah <omouse@gmail.com>
;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(eval-when-compile
(require 'compile)
(require 'cl))
(define-derived-mode processing-mode
java-mode "Processing"
"Major mode for Processing.
\\{java-mode-map}")
(defvar processing-location nil
"The directory where Processing can be found. Assumes you have
downloaded the standalone package.")
(defconst processing-platform
(cond ((string= system-type "gnu/linux")
"linux")
((or (string= system-type "darwin") (string= system-type "macos"))
"macosx")
((or (string= system-type "ms-dos") (string= system-type "windows-nt")
(string= system-type "cygwin"))
"windows"))
"The platform that Processing is running on. It can be `linux', `macosx' or `windows'.")
;; Functions
(defun make-java-classpath (&rest args)
"Returns a string that is a Java CLASSPATH. Each arg is a
folder containing .class files or a .jar. The delimiter is based
on the platform, with MS Windows using \";\", and other platforms
using \":\"."
(reduce (lambda (x y) (concat x (if (string= processing-platform "windows") ";" ":")
y))
args))
(defvar processing-import-libraries
'((minim "jl1.0" "mp3spi1.9.4" "tritonus_share" "tritonus_aos"
"minim-spi" "minim" "jsminim"))
"An alist of library names and the JAR (Java ARchive) files
required for their use. Each element looks like (library-name
&REST jar-files) where library-name is a SYMBOL and jar-files are
strings.")
(defun processing-import-library (library-name)
"Generates a STRING that is a Java classpath. The paths are
constructed from the REST of the library found in the alist
``processing-import-libraries''. The suffix \".jar\" is added to
each string."
(make-java-classpath (mapcar (lambda (x) (expand-file-name (concat processing-location
"libraries/"
(symbol-name library-name)
"/library/" x ".jar")))
(rest (assoc library-name processing-import-libraries)))))
(defun processing-read-libraries (sketch-dir)
"Returns a LIST of SYMBOLS that are the names of Processing
libraries. This list if stored in the \"libraries_required.txt\"
file found in the Processing sketch directory ``sketch-dir''.
If the file does not exist, it is assumed that there are no
libraries required and NIL is returned.
A general error is signalled if the library is not supported.
Check the variable ``processing-import-libraries'' to see which
libraries are supported."
(let ((file-name (expand-file-name (concat sketch-dir "libraries_required.txt"))))
(if (and (file-exists-p file-name) (file-readable-p file-name))
(let ((temp-buf (generate-new-buffer "libraries-required-by-sketch")))
(set-buffer temp-buf)
(insert-file-contents file-name)
(unwind-protect
(loop while (< (point) (buffer-size))
for library-name = (read temp-buf) then (read-temp-buf)
if (assoc library-name processing-import-libraries)
collect library-name
else do (error "Processing-mode does not know how to handle the library %s"
library-name)
do (forward-line))
(kill-buffer temp-buf)))
nil)))
(defun processing-make-compile-command (sketch-dir output-dir cmd &optional platform)
"Returns a string which is the compile-command for Processing
sketches, targetting the sketch files found in ``sketch-dir'',
with the output being stored in ``output-dir''. The command flag
that is executed on the sketch depends on the type of ``cmd''.
Valid types of commands are:
- \"preprocess\"
- \"build\"
- \"run\"
- \"present\"
- \"export-applet\"
- \"export-application\"
When ``cmd'' is set to \"export-application\", the ``platform''
must be set to one of \"windows\", \"macosx\", or \"linux\". If
no platform is selected, the default platform that Emacs is
running on will be selected."
(concat (file-name-as-directory processing-location)
"java/bin/java -classpath \""
(apply 'make-java-classpath
(mapcar (lambda (x) (expand-file-name (concat processing-location x)))
'("java/lib/rt.jar"
"java/lib/tools.jar"
"lib/antlr.jar" "lib/core.jar"
"lib/ecj.jar" "lib/jna.jar"
"lib/pde.jar")))
"\" processing.app.Commander"
" --sketch=\"" (expand-file-name sketch-dir)
"\" --output=\"" (expand-file-name output-dir)
;; Remove this comment when Processing implements the --preferences=??? command-line option.
;;"\" --preferences=\"" (expand-file-name "~/.processing/preferences.txt")
"\" --" cmd
(if (string= cmd "export-application")
(concat " --platform="
(if platform platform (processing-platform))))))
(defun processing-commander (sketch-dir output-dir cmd &optional platform)
"Runs the Processing compiler, using a compile-command
constructed using the ``processing-make-compile-command''
function."
(let ((compilation-error-regexp-alist '(processing)))
(compile (processing-make-compile-command sketch-dir output-dir cmd platform))))
(defun processing-sketch-compile (&optional cmd)
"Runs the Processing Commander application with the current
buffer. The output directory is the sub-directory ``output''
which will be found in the parent directory of the buffer file."
(interactive)
;; TODO: Add support for temporary sketches
(let ((sketch-dir (file-name-directory buffer-file-name)))
(processing-commander sketch-dir (concat sketch-dir "output") (if cmd cmd "run"))))
(defun processing-sketch-present ()
(interactive)
(processing-sketch-compile "present"))
(defun processing-sketch-build ()
"Runs the build command for a Processing sketch. Processing
will process the sketch into .java files and then compile them
into .class files."
(interactive)
(processing-sketch-compile "build"))
(defun processing-export-application ()
"Turns the Processing sketch into a Java application. Assumes
that the platform target is whatever platform Emacs is running
on."
t)
;; Add hook so that when processing-mode is loaded, the local variable
;; 'compile-command is set.
(add-hook 'processing-mode-hook
(lambda ()
(let ((sketch-dir (file-name-directory buffer-file-name)))
(set (make-local-variable 'compile-command)
(processing-make-compile-command sketch-dir
(concat sketch-dir "output")
"build")))))
;; Key bindings
(define-key processing-mode-map "\C-c\C-r" 'processing-sketch-compile)
(define-key processing-mode-map "\C-c\C-p" 'processing-sketch-present)
(define-key processing-mode-map "\C-c\C-b" 'processing-sketch-build)
;; Regular expressions
;; Compilation
(pushnew
;; Mode name, REGEXP FILE LINE COLUMN TYPE HYPERLINK HIGHLIGHT
'(processing "^\\([[:alnum:]]+.pde\\):\\([0-9]+\\):\\([0-9]+\\):.*$"
1 2 3)
compilation-error-regexp-alist-alist)
;; Font-lock, keywords
(defconst processing-font-lock-keywords-1
(eval-when-compile
`( ;; Shape functions
(,(concat
(regexp-opt '("triangle" "line" "arc" "point" "quad" "ellipse"
"rect" "curve" "bezier")
t)
"(") 1 font-lock-function-name-face t)
(,(concat
(regexp-opt '("strokeWeight" "smooth" "strokeJoin" "noSmooth"
"ellipseMode" "rectMode" "background" "stroke")
t)
"(") 1 font-lock-doc-face t)
(,(regexp-opt '("width" "height" "frameRate" "frameCount" "noCursor()" "cursor()")
t)
. font-lock-constant-face)
(,(concat "screen." (regexp-opt '("width" "height") t))
1 font-lock-constant-face t)
))
"Subdued level highlighting for Processing mode.")
;;(defconst processing-font-lock-keywords-2
;; (append processing-font-lock-keywords-1
;; (eval-when-compile
;; `(
(defvar processing-font-lock-keywords processing-font-lock-keywords-1
"Default expressions to highlight in Processing mode.")
;; YASnippets
(if (fboundp 'yas/minor-mode)
(progn
(require 'yasnippet)
(message "processing-mode: defining YASnippets")
(yas/define-snippets
'processing-mode
'(
;; (key template name condition)
("tri" "triangle(${x1}, ${y1}, ${x2}, ${y2}, ${x3}, ${y3});"
"triangle" nil)
("l(" "line(${x1}, ${y1}, ${x2}, ${y2});" "line 2d" nil)
("l(.3d" "line(${x1}, ${y1}, ${z1}, ${x2}, ${y2}, ${z2});" "line 3d" nil)
("arc" "arc(${x}, ${y}, ${width}, ${height}, ${start}, ${stop});" "arc" nil)
("p(" "point(${x}, ${y});" "point 2d" nil)
("p(.3d" "point(${x}, ${y}, ${z});" "point 3d" nil)
("quad" "quad(${x1}, ${y1}, ${x2}, ${y2}, ${x3}, ${y3}, ${x4}, ${y4});"
"quad" nil)
("ell" "ellipse(${x}, ${y}, ${width}, ${height});" "ellipse" nil)
("rect" "rect(${x}, ${y}, ${width}, ${height});" "rect" nil)
;; Color Setting
("background" "background(${gray_or_color_or_hex});" "background .." nil)
("background.ca" "background(${gray_or_color_or_hex}, ${alpha});"
"background .. alpha" nil)
("background.rgb" "background(${red}, ${green}, ${blue});" "background RGB" nil)
("background.rgba" "background(${red}, ${green}, ${blue}, ${alpha});"
"background RGBA" nil)
("colorm" "colorMode(${RGB_or_HSV});" "color mode" nil)
("colorm.r" "colorMode(${RGB_or_HSV}, ${range});" "color mode range" nil)
("colorm.rgb" "colorMode(${RGB_or_HSV}, ${range1}, ${range2}, ${range3});"
"color mode RGB/HSV range" nil)
("colorm.rgba" "colorMode(${RGB_or_HSV}, ${range1}, ${range2}, ${range3}, ${range4});"
"color mode RGB/HSV, A range" nil)
("stroke" "stroke(${gray_or_color_or_hex});" "stroke .." nil)
("stroke.ca" "stroke(${gray_or_color_or_hex}, ${alpha});" "stroke .. alpha" nil)
("stroke.rgb" "stroke(${red}, ${green}, ${blue});" "stroke RGB" nil)
("stroke.rgba" "stroke(${red}, ${green}, ${blue}, ${alpha});" "stroke RGBA" nil)
("fill" "fill(${gray_or_color_or_hex});" "fill .." nil)
("fill.ca" "fill(${gray_or_color_or_hex}, ${alpha});" "fill .. alpha" nil)
("fill.rgb" "fill(${red}, ${green}, ${blue});" "fill RGB" nil)
("fill.rgba" "fill(${red}, ${green}, ${blue}, ${alpha});" "fill RGBA" nil)
)
'java-mode)
t)
(progn
(message "processing-mode: YASnippets not installed. Not defining any snippets.")
nil))
(provide 'processing-mode)
