emacs-orgmode@gnu.org archives
 help / color / mirror / code / Atom feed
* PATCH: Processing language support in Babel
@ 2015-03-13 12:51 Jarmo Hurri
  2015-03-16 21:51 ` Nicolas Goaziou
  0 siblings, 1 reply; 3+ messages in thread
From: Jarmo Hurri @ 2015-03-13 12:51 UTC (permalink / raw)
  To: emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 1906 bytes --]


Greetings.

Please find two files attached to this message.

1. A patch implementing Processing programming language support in
   Babel. The commit message of the patch is the following:

   ********************************************************************
   ob-processing.el: Support for Processing language in Babel

   * lisp/ob-processing.el: Necessary functions for implementing editing
   and execution of Processing code blocks, and HTML export of the
   resulting Processing sketch.

   Editing Processing blocks requires processing2-emacs mode. Executing
   Processing blocks in Org buffer also requires processing2-emacs, and
   results in the sketch being shown in an external viewer. Such an
   execution produces no results in Org buffer. HTML export of the
   results of a Processing block is also supported, assuming that the
   processing.js module is available: the sketch is then drawn by the
   browser when the HTML page is viewed. This drawing is implemented by
   embedding the Processing code in a script using the processing.js
   module. The user is responsible for making sure that processing.js is
   available in the correct location.

   Console output from a Processing block produced e.g. by println() is
   shown in the Processing compilation window when the code is executed
   in Org buffer, and in text area (console) of the browser when the code
   is embedded in HTML.
   ********************************************************************

2. File test.org, illustrating the use of Processing in Org. The HTML
   export of this file can be viewed at

   http://www.syk.fi/~jhurri/org-processing/test.html

   The sketches (figures) on the page will be re-initialised on page
   reload.

I will be writing teaching material using a combination of Org and
Processing, and may add features to Processing support when and if I
find the need.

All the best,

Jarmo


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: patch --]
[-- Type: text/x-patch, Size: 9038 bytes --]

From 92318f56b2968b05cfbfb894d3b1eee4c7cdde13 Mon Sep 17 00:00:00 2001
From: Jarmo Hurri <jarmo.hurri@iki.fi>
Date: Fri, 13 Mar 2015 14:36:46 +0200
Subject: [PATCH] ob-processing.el: Support for Processing language in Babel

* lisp/ob-processing.el: Necessary functions for implementing editing
and execution of Processing code blocks, and HTML export of the
resulting Processing sketch.

Editing Processing blocks requires processing2-emacs mode. Executing
Processing blocks in Org buffer also requires processing2-emacs, and
results in the sketch being shown in an external viewer. Such an
execution produces no results in Org buffer. HTML export of the
results of a Processing block is also supported, assuming that the
processing.js module is available: the sketch is then drawn by the
browser when the HTML page is viewed. This drawing is implemented by
embedding the Processing code in a script using the processing.js
module. The user is responsible for making sure that processing.js is
available in the correct location.

Console output from a Processing block produced e.g. by println() is
shown in the Processing compilation window when the code is executed
in Org buffer, and in text area (console) of the browser when the code
is embedded in HTML.
---
 lisp/ob-processing.el | 201 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 201 insertions(+)
 create mode 100644 lisp/ob-processing.el

diff --git a/lisp/ob-processing.el b/lisp/ob-processing.el
new file mode 100644
index 0000000..fb74b55
--- /dev/null
+++ b/lisp/ob-processing.el
@@ -0,0 +1,201 @@
+;;; ob-processing.el --- org-babel functions for evaluation of processing
+
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
+
+;; Author: Jarmo Hurri (adapted from ob-asymptote.el written by Eric Schulte)
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs 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.
+
+;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating processing source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in processing
+;;
+;; 2) results can only be exported as html; in this case, the
+;;    processing code is embedded via a file into a javascript block
+;;    using the processing.js module; the script then draws the
+;;    resulting output when the web page is viewed in a browser
+;;
+;; 3) when not exporting html, evaluation of processing code results
+;;    in interactive viewing of the results via Processing 2.0 Emacs
+;;    mode; note that the user is responsible for making sure that
+;;    processing.js is available on the website
+
+;;; Requirements:
+
+;; - processing2-emacs mode :: https://github.com/ptrv/processing2-emacs
+;; - Processing.js module :: http://processingjs.org/
+
+;;; Code:
+(require 'ob)
+(require 'ox)
+
+(eval-when-compile (require 'cl))
+
+;; declaration needed because requiring ob does not define the variable
+(eval-when-compile (defvar org-babel-temporary-directory))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("processing" . "pde"))
+
+;; default header tags depend on whether exporting html or not; if not
+;; exporting html, then no results are produced; otherwise results are
+;; html
+(defvar org-babel-default-header-args:processing
+  '((:results . (or (and org-export-current-backend "html")  "none"))
+    (:exports . "results"))
+  "Default arguments when evaluating a Processing source block.")
+
+(defvar org-babel-processing-processing-js-filename
+  "processing.js"
+  "Filename of the processing.js file.")
+
+;; a running index for producing unique ids for processing sketches
+(defvar org-babel-processing-sketch-number 0)
+(add-hook 'org-export-before-processing-hook
+	  (lambda (backend) (setq org-babel-processing-sketch-number 0)))
+
+;; declaration of needed function from processing mode in case
+;; processing-mode is not available
+(if (null (require 'processing-mode nil :noerror))
+  (declare-function processing-sketch-run "processing-mode.el" nil))
+
+(defun org-babel-execute:processing (body params)
+  "Execute a block of Processing code.
+This function is called by `org-babel-execute-src-block'."
+  (let ((sketch-code
+	 (org-babel-expand-body:generic
+	  body
+	  params
+	  (org-babel-variable-assignments:processing params))))
+    (if (and (not (null org-babel-exp-reference-buffer))
+	     (string= org-export-current-backend "html"))
+	;; results are html if exporting html
+	(let ((sketch-canvas-id
+	       (concat "org-processing-canvas-"
+		       (number-to-string org-babel-processing-sketch-number))))
+	  (setq org-babel-processing-sketch-number
+		(1+ org-babel-processing-sketch-number))
+	  (concat "<script src=\""
+		  org-babel-processing-processing-js-filename
+		  "\"></script>\n <script type=\"text/processing\""
+		  " data-processing-target=\""
+		  sketch-canvas-id
+		  "\">\n"
+		  sketch-code
+		  "\n</script> <canvas id=\""
+		  sketch-canvas-id
+		  "\"></canvas>"))
+      ;; if not exporting html, show sketch in external viewer
+      ;; note: sketch filename can not contain a hyphen, since it has to be
+      ;; a valid java class name - for this reason make-temp-file is repeated
+      ;; until no hyphen is in the name; also sketch dir name must be the same
+      ;; as the basename of the sketch file
+      (let* ((temporary-file-directory org-babel-temporary-directory)
+	     (sketch-dir
+	      (let (sketch-dir-candidate)
+		(while
+		    (progn
+		      (setq sketch-dir-candidate
+			    (make-temp-file "processing" t))
+		      (if (string-match
+			   "-"
+			   (file-name-nondirectory sketch-dir-candidate))
+			  (progn
+			    (delete-directory sketch-dir-candidate)
+			    t)
+			nil)))
+		sketch-dir-candidate))
+	     (sketch-filename
+	      (concat sketch-dir
+		      "/"
+		      (file-name-nondirectory sketch-dir)
+		      ".pde")))
+	(with-temp-file sketch-filename (insert sketch-code))
+	(find-file sketch-filename)
+	(processing-sketch-run)
+	(kill-buffer)
+	nil)))) ;; signal no output in this case
+
+(defun org-babel-prep-session:processing (session params)
+  "Return an error if the :session header argument is set.
+Processing does not support sessions"
+  (error "Processing does not support sessions"))
+
+(defun org-babel-variable-assignments:processing (params)
+  "Return list of processing statements assigning the block's variables."
+  (mapcar #'org-babel-processing-var-to-processing
+	  (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-processing-var-to-processing (pair)
+  "Convert an elisp value into a Processing variable.
+The elisp value PAIR is converted into Processing code specifying
+a variable of the same value."
+  (let ((var (car pair))
+        (val (let ((v (cdr pair)))
+	       (if (symbolp v) (symbol-name v) v))))
+    (cond
+     ((integerp val)
+      (format "int %S=%S;" var val))
+     ((floatp val)
+      (format "float %S=%S;" var val))
+     ((stringp val)
+      (format "String %S=\"%s\";" var val))
+     ((and (listp val) (not (listp (car val))))
+      (let* ((type (org-babel-processing-define-type val))
+	     (fmt (if (eq 'String type) "\"%s\"" "%s"))
+	     (vect (mapconcat (lambda (e) (format fmt e)) val ", ")))
+	(format "%s[] %S={%s};" type var vect)))
+     ((listp val)
+      (let* ((type (org-babel-processing-define-type val))
+	     (fmt (if (eq 'String type) "\"%s\"" "%s"))
+             (array (mapconcat (lambda (row)
+				 (concat "{"
+					 (mapconcat (lambda (e) (format fmt e))
+						    row ", ")
+					 "}"))
+			       val ",")))
+        (format "%S[][] %S={%s};" type var array))))))
+
+(defun org-babel-processing-define-type (data)
+  "Determine type of DATA.
+
+DATA is a list.  Return type as a symbol.
+
+The type is `String' if any element in DATA is
+a string.  Otherwise, it is either `float', if some elements are
+floats, or `int'."
+  (let* ((type 'int)
+	 find-type			; for byte-compiler
+	 (find-type
+	  (function
+	   (lambda (row)
+	     (catch 'exit
+	       (mapc (lambda (el)
+		       (cond ((listp el) (funcall find-type el))
+			     ((stringp el) (throw 'exit (setq type 'String)))
+			     ((floatp el) (setq type 'float))))
+		     row))))))
+    (funcall find-type data) type))
+
+(provide 'ob-processing)
+
+;;; ob-processing.el ends here
-- 
1.9.3


[-- Attachment #3: testfile --]
[-- Type: application/octet-stream, Size: 1522 bytes --]

* dynamic

  #+BEGIN_SRC processing :exports both
    final int W = 800;
    final int H = 600;
    final int SUN_D = 300;
    final int MOON_D = SUN_D - 10;
    final int MIDPOINT_X = W / 2;
    final int MIDPOINT_Y = H / 2;

    float moonX = MIDPOINT_X + MOON_D;

    void setup ()
    {
      size (W, H);
      noStroke ();
    }

    void draw ()
    {
      background (0);
      fill (color (255, 255, 0));
      ellipse (MIDPOINT_X, MIDPOINT_Y, SUN_D, SUN_D);

      if (moonX + MOON_D / 2 >= 0)
      {
        fill (color (0));
        ellipse (moonX, MIDPOINT_Y, MOON_D, MOON_D);
        moonX -= 0.4;
      }
    }
  #+END_SRC
* static
  #+BEGIN_SRC processing :exports both
    final int W = 1024, H = 768;
    final int COLOR_MAX = 255;
    size (W, H);
    background (COLOR_MAX);
    colorMode (HSB, COLOR_MAX, COLOR_MAX, COLOR_MAX); 
    noStroke ();

    for (int i = 0; i < 30; i++)
     {
       fill (color (random (COLOR_MAX), COLOR_MAX, COLOR_MAX, 0.3 * COLOR_MAX));
   
       float x = random (W - 1);
       float y = random (H - 1);
   
       float r = random (min (min (x, W - 1 - x), min (y, H - 1 - y))); 
   
       if (r > 0)
       {
         float d = 2 * r;
         ellipse (x, y, d, d);
       }
     }

  #+END_SRC

* passing variables and console output

  #+BEGIN_SRC processing :var textSz=32 :var title="Org rules!" :var factor=0.3 :exports both
    size (400, 300);
    textSize (textSz);
    text (title, factor * width, 100);
    println ("console output text");
  #+END_SRC

^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: PATCH: Processing language support in Babel
  2015-03-13 12:51 PATCH: Processing language support in Babel Jarmo Hurri
@ 2015-03-16 21:51 ` Nicolas Goaziou
  2015-03-31  7:32   ` Jarmo Hurri
  0 siblings, 1 reply; 3+ messages in thread
From: Nicolas Goaziou @ 2015-03-16 21:51 UTC (permalink / raw)
  To: Jarmo Hurri; +Cc: emacs-orgmode

Hello,

Jarmo Hurri <jarmo.hurri@iki.fi> writes:

> Please find two files attached to this message.

Thank you.

> +;; This differs from most standard languages in that
> +;;
> +;; 1) there is no such thing as a "session" in processing
> +;;
> +;; 2) results can only be exported as html; in this case, the
> +;;    processing code is embedded via a file into a javascript block
> +;;    using the processing.js module; the script then draws the
> +;;    resulting output when the web page is viewed in a browser
> +;;
> +;; 3) when not exporting html, evaluation of processing code results
> +;;    in interactive viewing of the results via Processing 2.0 Emacs
> +;;    mode; note that the user is responsible for making sure that
> +;;    processing.js is available on the website

It is awkward (and fragile) to guess the current export back-end used.
Wouldn't it be simpler to do "2" if :results is html and "3" otherwise?

> +;; declaration needed because requiring ob does not define the variable
> +(eval-when-compile (defvar org-babel-temporary-directory))

Isn't

  (defvar org-babel-temporary-directory)

sufficient?

> +;; default header tags depend on whether exporting html or not; if not
> +;; exporting html, then no results are produced; otherwise results are
> +;; html

It shouldn't.

> +;; a running index for producing unique ids for processing sketches
> +(defvar org-babel-processing-sketch-number 0)
> +(add-hook 'org-export-before-processing-hook
> +	  (lambda (backend) (setq org-babel-processing-sketch-number 0)))

It pollutes `org-export-before-processing-hook'. What about using sha1
of the contents of the code block instead?

> +(defun org-babel-execute:processing (body params)
> +  "Execute a block of Processing code.
> +This function is called by `org-babel-execute-src-block'."
> +  (let ((sketch-code
> +	 (org-babel-expand-body:generic
> +	  body
> +	  params
> +	  (org-babel-variable-assignments:processing params))))
> +    (if (and (not (null org-babel-exp-reference-buffer))
> +	     (string= org-export-current-backend "html"))

This will not work if current back-end is derived from "html".

> +	;; results are html if exporting html
> +	(let ((sketch-canvas-id
> +	       (concat "org-processing-canvas-"
> +		       (number-to-string org-babel-processing-sketch-number))))

  (format "org-processing-canvas-%d" org-babel-processing-sketch-number)

> +	  (setq org-babel-processing-sketch-number
> +		(1+ org-babel-processing-sketch-number))

  (incf org-babel-processing-sketch-number)

> +(defun org-babel-processing-define-type (data)
> +  "Determine type of DATA.
> +
> +DATA is a list.  Return type as a symbol.
> +
> +The type is `String' if any element in DATA is
> +a string.  Otherwise, it is either `float', if some elements are
> +floats, or `int'."
> +  (let* ((type 'int)
> +	 find-type			; for byte-compiler
> +	 (find-type
> +	  (function

Not needed.

> +	   (lambda (row)
> +	     (catch 'exit
> +	       (mapc (lambda (el)
> +		       (cond ((listp el) (funcall find-type el))
> +			     ((stringp el) (throw 'exit (setq type 'String)))
> +			     ((floatp el) (setq type 'float))))
> +		     row))))))

  (lambda (row)
    (dolist (el row type)
      (cond ...)))

> +    (funcall find-type data) type))
                                ^^^^
                              not needed

Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 3+ messages in thread

* Re: PATCH: Processing language support in Babel
  2015-03-16 21:51 ` Nicolas Goaziou
@ 2015-03-31  7:32   ` Jarmo Hurri
  0 siblings, 0 replies; 3+ messages in thread
From: Jarmo Hurri @ 2015-03-31  7:32 UTC (permalink / raw)
  To: emacs-orgmode


Greetings.

Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

>> +;; This differs from most standard languages in that
>> +;;
>> +;; 1) there is no such thing as a "session" in processing
>> +;;
>> +;; 2) results can only be exported as html; in this case, the
>> +;;    processing code is embedded via a file into a javascript block
>> +;;    using the processing.js module; the script then draws the
>> +;;    resulting output when the web page is viewed in a browser
>> +;;
>> +;; 3) when not exporting html, evaluation of processing code results
>> +;;    in interactive viewing of the results via Processing 2.0 Emacs
>> +;;    mode; note that the user is responsible for making sure that
>> +;;    processing.js is available on the website
>
> It is awkward (and fragile) to guess the current export back-end used.
> Wouldn't it be simpler to do "2" if :results is html and "3" otherwise?

What the user will want is to view the sketch in an external viewer when
not exporting, so (s)he can see what will eventually be exported. So the
user would have :results html set, but would still like to do "3" in the
buffer.

I think what I could try to do is to bind some key combination so that
it will do "3" when inside a Processing block. That is, remove "3" from
org-babel-execute-processing. What would also solve some other issues
you mention below. Would that be ok?

>> +;; declaration needed because requiring ob does not define the variable
>> +(eval-when-compile (defvar org-babel-temporary-directory))
>
> Isn't
>
>   (defvar org-babel-temporary-directory)
>
> sufficient?

Could be, but it would mean that that variable would be defvar'd
multiple times (when not compiling). Maybe that is ok in elisp, but it
sounds weird programming practice to me. Or?

>> +;; default header tags depend on whether exporting html or not; if not
>> +;; exporting html, then no results are produced; otherwise results are
>> +;; html
>
> It shouldn't.

Ok, this was addressed in the suggestion above.

>> +;; a running index for producing unique ids for processing sketches
>> +(defvar org-babel-processing-sketch-number 0)
>> +(add-hook 'org-export-before-processing-hook
>> +	  (lambda (backend) (setq org-babel-processing-sketch-number 0)))
>
> It pollutes `org-export-before-processing-hook'. What about using sha1
> of the contents of the code block instead?

I'll do that.

>> +(defun org-babel-execute:processing (body params)
>> +  "Execute a block of Processing code.
>> +This function is called by `org-babel-execute-src-block'."
>> +  (let ((sketch-code
>> +	 (org-babel-expand-body:generic
>> +	  body
>> +	  params
>> +	  (org-babel-variable-assignments:processing params))))
>> +    (if (and (not (null org-babel-exp-reference-buffer))
>> +	     (string= org-export-current-backend "html"))
>
> This will not work if current back-end is derived from "html".

Addressed above.

>> +	;; results are html if exporting html
>> +	(let ((sketch-canvas-id
>> +	       (concat "org-processing-canvas-"
>> +		       (number-to-string org-babel-processing-sketch-number))))
>
>   (format "org-processing-canvas-%d" org-babel-processing-sketch-number)
>
>> +	  (setq org-babel-processing-sketch-number
>> +		(1+ org-babel-processing-sketch-number))
>
>   (incf org-babel-processing-sketch-number)
>
>> +(defun org-babel-processing-define-type (data)
>> +  "Determine type of DATA.
>> +
>> +DATA is a list.  Return type as a symbol.
>> +
>> +The type is `String' if any element in DATA is
>> +a string.  Otherwise, it is either `float', if some elements are
>> +floats, or `int'."
>> +  (let* ((type 'int)
>> +	 find-type			; for byte-compiler
>> +	 (find-type
>> +	  (function
>
> Not needed.

Which part is not needed? This was adapted directly from
ob-asymptote.el. Is it unnecessary there as well?

>> +	   (lambda (row)
>> +	     (catch 'exit
>> +	       (mapc (lambda (el)
>> +		       (cond ((listp el) (funcall find-type el))
>> +			     ((stringp el) (throw 'exit (setq type 'String)))
>> +			     ((floatp el) (setq type 'float))))
>> +		     row))))))
>
>   (lambda (row)
>     (dolist (el row type)
>       (cond ...)))
>
>> +    (funcall find-type data) type))
>                                 ^^^^
>                               not needed

Unnecessary in ob-asymptote.el as well?

I'll proceed to implement the changes once I get an ok from you.

All the best,

Jarmo

^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2015-03-31  7:32 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-03-13 12:51 PATCH: Processing language support in Babel Jarmo Hurri
2015-03-16 21:51 ` Nicolas Goaziou
2015-03-31  7:32   ` Jarmo Hurri

Code repositories for project(s) associated with this inbox:

	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).