parameterizing keyword values during a #+call

parameterizing keyword values during a #+call

[Greg Minshall]

hi.  i would have an org file that uses lots of #+calls to various
asymptote routines (babelled into the file) to produce graphics.  i
would like to export this file to both html and to latex (specifically
beamer).  for html, i would like, e.g., SVG files, and for latex, PDF
files.  the file name is normally passed to the asymptote routine via a
:file parameter, to wit
----
#+call: disc[:file images/disc.svg]() :results file
----
and the file extension (".svg" in the above) determines the format of
the asymptote output.

is there an obvious way to allow the file extension to take on different
values depending on which sort of export is driving its execution?  i
had hoped that replacing ".svg" with something like ".{{{ext()}}}",
where "ext" was a macro which selected amongst the alternatives(*),
would do the trick.  but that doesn't appear to be the case.

thanks in advance (and with full appreciation of what a pain macros
are to implement fully, halfly, anyly), Greg Minshall

(*)
#+MACRO: ext @@latex:pdf@@@@beamer:pdf@@@@html:svg@@

Re: parameterizing keyword values during a #+call

[Eric Schulte]

Greg Minshall <minshall@umich.edu> writes:

> hi.  i would have an org file that uses lots of #+calls to various
> asymptote routines (babelled into the file) to produce graphics.  i
> would like to export this file to both html and to latex (specifically
> beamer).  for html, i would like, e.g., SVG files, and for latex, PDF
> files.  the file name is normally passed to the asymptote routine via a
> :file parameter, to wit
> ----
> #+call: disc[:file images/disc.svg]() :results file
> ----
> and the file extension (".svg" in the above) determines the format of
> the asymptote output.
>
> is there an obvious way to allow the file extension to take on different
> values depending on which sort of export is driving its execution?  i
> had hoped that replacing ".svg" with something like ".{{{ext()}}}",
> where "ext" was a macro which selected amongst the alternatives(*),
> would do the trick.  but that doesn't appear to be the case.
>

Something like the following should work.

#+call: disc[:file (if (and (boundp org-export-current-backend) (equal org-export-current-backend 'html)) "foo.svg" "foo.tex")]() :results file

And you could wrap up the extra-long Emacs-lisp in a function or macro
in your init to avoid the overlength header argument.

>
> thanks in advance (and with full appreciation of what a pain macros
> are to implement fully, halfly, anyly), Greg Minshall
>
> (*)
> #+MACRO: ext @@latex:pdf@@@@beamer:pdf@@@@html:svg@@
>

-- 
Eric Schulte
http://cs.unm.edu/~eschulte

Re: parameterizing keyword values during a #+call

[Greg Minshall]

Eric,

thanks!

> Something like the following should work.
>
> #+call: disc[:file (if (and (boundp org-export-current-backend) (equal org-export-current-backend 'html)) "foo.svg" "foo.tex")]() :results file

in fact, with the new exporter, org-export-current-backend has
bit the dust, but apparently the non-architected "backend" exists.  the
following works great!!
----
#+call: discs[:file (if (and (boundp 'backend) (equal backend 'html)) "fox.svg" "fox.pdf")]() :results file
----
(note the tick in the (boundp 'backend)).

now to wedge it into some init code.

cheers, Greg

Re: parameterizing keyword values during a #+call

[Greg Minshall]

Eric,

> And you could wrap up the extra-long Emacs-lisp in a function or macro
> in your init to avoid the overlength header argument.

is it possible to embed the function inside the .org file itself?  (in
order to promote sharing of .org files, without needing any
more-than-necessary ancillary state to accompany the file.)

(i can imagine the file extension == file type being a parameter to the
asymptote routines, but i'd *rather* have it pass in the :file
parameter.)

cheers, Greg

Re: parameterizing keyword values during a #+call

[Eric Schulte]

Greg Minshall <minshall@umich.edu> writes:

> Eric,
>
>> And you could wrap up the extra-long Emacs-lisp in a function or macro
>> in your init to avoid the overlength header argument.
>
> is it possible to embed the function inside the .org file itself?  (in
> order to promote sharing of .org files, without needing any
> more-than-necessary ancillary state to accompany the file.)
>
> (i can imagine the file extension == file type being a parameter to the
> asymptote routines, but i'd *rather* have it pass in the :file
> parameter.)
>

You could put the emacs-lisp code into an emacs-lisp code block which is
exported but has a result type of "none" or "silent".

Best,

>
> cheers, Greg

-- 
Eric Schulte
http://cs.unm.edu/~eschulte

Re: parameterizing keyword values during a #+call

[Greg Minshall]

Eric,

> You could put the emacs-lisp code into an emacs-lisp code block which
> is exported but has a result type of "none" or "silent".

ah -- i should have tried that!  that works -- thanks *very* much!

cheers, Greg

Re: parameterizing keyword values during a #+call

[Greg Minshall]

Eric,

just for completeness, and in case this may be of use to other people,
below is the result of my question + your suggestions.  the following
illustrates org-mode plus asymptote producing a .svg file during html
export, and a pdf file during any other (presumably, latex) export.

thanks again, Greg
----
# trying to get graphics that works for both latex/beamer and for html

# here's a suggestion from Eric Schulte
# http://article.gmane.org/gmane.emacs.orgmode/71301
# with this clarification
# http://article.gmane.org/gmane.emacs.orgmode/71393
# which produced the following

# we define an emacs lisp macro ext that produces a file extension
# of "svg" or "pdf" depending on whether we are exporting to html or
# to some other source.  this macro is called when computing the
# output file name argument in a call to an asymptote routine as in:
#
# #+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file
#
# which calls an asymptote routine (defined in our file) called
# rectangle to produce a file called twod-1.svg or twod-1.pdf.

# define the ext emacs lisp macro (i think in the following you *need*
# ":exports results" -- instead of ":exports none" -- to make sure the
# code is executed during export; the ":results silent" keeps any
# output -- or nil -- from showing up in the output file.)

#+begin_src emacs-lisp :exports results :results silent
    (defmacro ext (base)
      (format "%s.%s" base
              (if (and (boundp 'backend) (equal backend 'html)) "svg" "pdf")))
#+end_src


# follows an example use of the above macro

# first, define a asymptote function (org-named "rectangle") that
# draws a rectangle
#+name: rectangle
#+begin_src asymptote :var TSIZE=1.0 :exports none
  import trembling;
  size(100);
  int off = 2, width = 100, height = 30;
  string tsize = format("%g", TSIZE);
  tremble tr0=tremble(angle=0);   // no trembling
  tremble tr10=tremble(angle=10,frequency=0.1,random=50,fuzz=1);
  
  picture rectangle(pair sw, pair ne, int offset, string text, tremble tr) {
    picture pic;
    path g =
      (sw.x+offset,sw.y+offset)--(ne.x-offset,sw.y+offset)--(ne.x-offset,ne.y-offset)--(sw.x+offset,ne.y-offset)--cycle;
    label(pic, text, ((sw.x+ne.x)/2, (sw.y+ne.y)/2));
    draw(pic, tr.deform(g));
    return pic;
  }
  
  add(rectangle((0,0),(width,height),0, "", tr0));
  add(rectangle((0,0),(width,height),off, tsize, tr10));
#+end_src

# now, invoke the above asymptote function, producing a file called
# either twod-1.svg or twod-1.pdf:

#+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file

# now, you can C-c C-e l o or C-c C-e h o and see the image in the
# two formats

# $Id: parameterizing.org,v 1.2 2013/04/30 14:37:29 minshall Exp $

Re: parameterizing keyword values during a #+call

[Gary Oberbrunner]

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

I've been having the same issue (exporting to HTML and PDF, and need all my
graphics filenames to adjust automatically).

I mostly don't use #+CALL though; I just have src blocks.

#+BEGIN_SRC python :session UDpython :exports results :results file
  do_hbar('/tmp/machines-by-os.pdf', (8,1.5), data)
#+END_SRC

Is there any way of interpolating the elisp value into the middle of a src
block?  I guess I can add another #+HEADER line:

#+HEADER: :var filename=(ext "/tmp/machines-by-os")
#+BEGIN_SRC python :session UDpython :exports results :results file
  do_hbar(filename, (8,1.5), data)
#+END_SRC

Is that the recommended method?

Org-mode macros that got expanded in the middle of babel source block text
would be cool. Just saying.



On Tue, Apr 30, 2013 at 10:40 AM, Greg Minshall <minshall@umich.edu> wrote:

> Eric,
>
> just for completeness, and in case this may be of use to other people,
> below is the result of my question + your suggestions.  the following
> illustrates org-mode plus asymptote producing a .svg file during html
> export, and a pdf file during any other (presumably, latex) export.
>
> thanks again, Greg
> ----
> # trying to get graphics that works for both latex/beamer and for html
>
> # here's a suggestion from Eric Schulte
> # http://article.gmane.org/gmane.emacs.orgmode/71301
> # with this clarification
> # http://article.gmane.org/gmane.emacs.orgmode/71393
> # which produced the following
>
> # we define an emacs lisp macro ext that produces a file extension
> # of "svg" or "pdf" depending on whether we are exporting to html or
> # to some other source.  this macro is called when computing the
> # output file name argument in a call to an asymptote routine as in:
> #
> # #+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file
> #
> # which calls an asymptote routine (defined in our file) called
> # rectangle to produce a file called twod-1.svg or twod-1.pdf.
>
> # define the ext emacs lisp macro (i think in the following you *need*
> # ":exports results" -- instead of ":exports none" -- to make sure the
> # code is executed during export; the ":results silent" keeps any
> # output -- or nil -- from showing up in the output file.)
>
> #+begin_src emacs-lisp :exports results :results silent
>     (defmacro ext (base)
>       (format "%s.%s" base
>               (if (and (boundp 'backend) (equal backend 'html)) "svg"
> "pdf")))
> #+end_src
>
>
> # follows an example use of the above macro
>
> # first, define a asymptote function (org-named "rectangle") that
> # draws a rectangle
> #+name: rectangle
> #+begin_src asymptote :var TSIZE=1.0 :exports none
>   import trembling;
>   size(100);
>   int off = 2, width = 100, height = 30;
>   string tsize = format("%g", TSIZE);
>   tremble tr0=tremble(angle=0);   // no trembling
>   tremble tr10=tremble(angle=10,frequency=0.1,random=50,fuzz=1);
>
>   picture rectangle(pair sw, pair ne, int offset, string text, tremble tr)
> {
>     picture pic;
>     path g =
>
> (sw.x+offset,sw.y+offset)--(ne.x-offset,sw.y+offset)--(ne.x-offset,ne.y-offset)--(sw.x+offset,ne.y-offset)--cycle;
>     label(pic, text, ((sw.x+ne.x)/2, (sw.y+ne.y)/2));
>     draw(pic, tr.deform(g));
>     return pic;
>   }
>
>   add(rectangle((0,0),(width,height),0, "", tr0));
>   add(rectangle((0,0),(width,height),off, tsize, tr10));
> #+end_src
>
> # now, invoke the above asymptote function, producing a file called
> # either twod-1.svg or twod-1.pdf:
>
> #+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file
>
> # now, you can C-c C-e l o or C-c C-e h o and see the image in the
> # two formats
>
> # $Id: parameterizing.org,v 1.2 2013/04/30 14:37:29 minshall Exp $
>
>


-- 
Gary

[-- Attachment #2: Type: text/html, Size: 4913 bytes --]

Re: parameterizing keyword values during a #+call

[Eric Schulte]

Gary Oberbrunner <garyo@oberbrunner.com> writes:

> I've been having the same issue (exporting to HTML and PDF, and need all my
> graphics filenames to adjust automatically).
>
> I mostly don't use #+CALL though; I just have src blocks.
>
> #+BEGIN_SRC python :session UDpython :exports results :results file
>   do_hbar('/tmp/machines-by-os.pdf', (8,1.5), data)
> #+END_SRC
>
> Is there any way of interpolating the elisp value into the middle of a src
> block?  I guess I can add another #+HEADER line:
>
> #+HEADER: :var filename=(ext "/tmp/machines-by-os")
> #+BEGIN_SRC python :session UDpython :exports results :results file
>   do_hbar(filename, (8,1.5), data)
> #+END_SRC
>
> Is that the recommended method?
>

It looks to me like it should work just fine.

>
> Org-mode macros that got expanded in the middle of babel source block
> text would be cool. Just saying.
>

I don't see the benefit of a macro expansion over the use of variables
as you demonstrate above.

Cheers,

>
>
>
> On Tue, Apr 30, 2013 at 10:40 AM, Greg Minshall <minshall@umich.edu> wrote:
>
>> Eric,
>>
>> just for completeness, and in case this may be of use to other people,
>> below is the result of my question + your suggestions.  the following
>> illustrates org-mode plus asymptote producing a .svg file during html
>> export, and a pdf file during any other (presumably, latex) export.
>>
>> thanks again, Greg
>> ----
>> # trying to get graphics that works for both latex/beamer and for html
>>
>> # here's a suggestion from Eric Schulte
>> # http://article.gmane.org/gmane.emacs.orgmode/71301
>> # with this clarification
>> # http://article.gmane.org/gmane.emacs.orgmode/71393
>> # which produced the following
>>
>> # we define an emacs lisp macro ext that produces a file extension
>> # of "svg" or "pdf" depending on whether we are exporting to html or
>> # to some other source.  this macro is called when computing the
>> # output file name argument in a call to an asymptote routine as in:
>> #
>> # #+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file
>> #
>> # which calls an asymptote routine (defined in our file) called
>> # rectangle to produce a file called twod-1.svg or twod-1.pdf.
>>
>> # define the ext emacs lisp macro (i think in the following you *need*
>> # ":exports results" -- instead of ":exports none" -- to make sure the
>> # code is executed during export; the ":results silent" keeps any
>> # output -- or nil -- from showing up in the output file.)
>>
>> #+begin_src emacs-lisp :exports results :results silent
>>     (defmacro ext (base)
>>       (format "%s.%s" base
>>               (if (and (boundp 'backend) (equal backend 'html)) "svg"
>> "pdf")))
>> #+end_src
>>
>>
>> # follows an example use of the above macro
>>
>> # first, define a asymptote function (org-named "rectangle") that
>> # draws a rectangle
>> #+name: rectangle
>> #+begin_src asymptote :var TSIZE=1.0 :exports none
>>   import trembling;
>>   size(100);
>>   int off = 2, width = 100, height = 30;
>>   string tsize = format("%g", TSIZE);
>>   tremble tr0=tremble(angle=0);   // no trembling
>>   tremble tr10=tremble(angle=10,frequency=0.1,random=50,fuzz=1);
>>
>>   picture rectangle(pair sw, pair ne, int offset, string text, tremble tr)
>> {
>>     picture pic;
>>     path g =
>>
>> (sw.x+offset,sw.y+offset)--(ne.x-offset,sw.y+offset)--(ne.x-offset,ne.y-offset)--(sw.x+offset,ne.y-offset)--cycle;
>>     label(pic, text, ((sw.x+ne.x)/2, (sw.y+ne.y)/2));
>>     draw(pic, tr.deform(g));
>>     return pic;
>>   }
>>
>>   add(rectangle((0,0),(width,height),0, "", tr0));
>>   add(rectangle((0,0),(width,height),off, tsize, tr10));
>> #+end_src
>>
>> # now, invoke the above asymptote function, producing a file called
>> # either twod-1.svg or twod-1.pdf:
>>
>> #+call: rectangle[:file (ext twod-1)](TSIZE=1.0) :results file
>>
>> # now, you can C-c C-e l o or C-c C-e h o and see the image in the
>> # two formats
>>
>> # $Id: parameterizing.org,v 1.2 2013/04/30 14:37:29 minshall Exp $
>>
>>

-- 
Eric Schulte
http://cs.unm.edu/~eschulte

Re: parameterizing keyword values during a #+call

[Greg Minshall]

Gary,

> Org-mode macros that got expanded in the middle of babel source block
> text would be cool. Just saying.

i agree with Eric's comment.  if you think of the issue of trying to
parse an arbitrary (and growing) number of languages, trying to avoid
language-specific constructions in your choice of macro-designator
(things like "@@..@@" or "{{..}}" or "$.." or...), etc., you will
probably fairly quickly come to see the benefits of :var as the way of
passing in inputs.

cheers, Greg