summaryrefslogtreecommitdiff
path: root/texmf-dist/source/latex/acrotex/insdljs.dtx
diff options
context:
space:
mode:
Diffstat (limited to 'texmf-dist/source/latex/acrotex/insdljs.dtx')
-rw-r--r--texmf-dist/source/latex/acrotex/insdljs.dtx2622
1 files changed, 2622 insertions, 0 deletions
diff --git a/texmf-dist/source/latex/acrotex/insdljs.dtx b/texmf-dist/source/latex/acrotex/insdljs.dtx
new file mode 100644
index 00000000..4194957b
--- /dev/null
+++ b/texmf-dist/source/latex/acrotex/insdljs.dtx
@@ -0,0 +1,2622 @@
+% \iffalse
+% makeindex -s gglo.ist -o insdljs.gls insdljs.glo
+% makeindex -s gind.ist -o insdljs.ind insdljs.idx
+%<*copyright>
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% insdljs.sty package, %%
+%% Copyright (C) 2001-2017 D. P. Story %%
+%% dpstory@uakron.edu %%
+%% %%
+%% This program can redistributed and/or modified under %%
+%% the terms of the LaTeX Project Public License %%
+%% Distributed from CTAN archives in directory %%
+%% macros/latex/base/lppl.txt; either version 1 of the %%
+%% License, or (at your option) any later version. %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%</copyright>
+%<package>\NeedsTeXFormat{LaTeX2e}
+%<package>\ProvidesPackage{insdljs}
+%<package> [2017/03/02 v2.3f Insert Document Level JavaScripts (dps)]
+%<*driver>
+\documentclass{ltxdoc}
+\usepackage[colorlinks,hyperindex=false]{hyperref}
+\usepackage{makeidx}
+\makeindex
+\def\EXPT{!}
+\pdfstringdefDisableCommands{\let\\\textbackslash}%
+% \OnlyDescription % comment out for implementation details
+\EnableCrossrefs
+\CodelineIndex
+\RecordChanges
+\gdef\darg#1{\texttt{\char123\relax#1\char125\relax}}
+\let\env\texttt
+\let\opt\texttt
+\let\app\textsf
+\let\pkg\textsf
+\def\visispace{\symbol{32}}
+\def\ameta#1{\ensuremath{\langle\textit{\texttt{#1}}\rangle}}
+\def\meta#1{\textsl{\texttt{#1}}}
+\def\SUB#1{\ensuremath{{}_{\mbox{\scriptsize\ttfamily#1}}}}
+
+\InputIfFileExists{aebdocfmt.def}{\PackageInfo{insdljs}{Inputting aebdocfmt.def}}
+ {\def\IndexOpt{\DescribeMacro}\def\IndexKey{\DescribeMacro}\let\setupFullwidth\relax
+ \PackageInfo{insdljs}{aebdocfmt.def cannot be found}}
+\begin{document}
+ \GetFileInfo{insdljs.sty}
+ \title{The \texttt{insDLJS} Package}
+ \author{D. P. Story\\
+ Email: \texttt{dpstory@uakron.edu}}
+ \date{processed \today}
+ \maketitle
+ \tableofcontents
+ \let\Email\texttt
+ \let\pkg\textsf
+ \DocInput{insdljs.dtx}
+\IfFileExists{\jobname.ind}{\newpage\setupFullwidth\PrintIndex}{\paragraph*{Index} The index goes here.\\Execute
+ \texttt{makeindex -s gind.ist -o insdljs.ind insdljs.idx} on the command line and recompile
+ \texttt{insdljs.dtx}.}
+\IfFileExists{\jobname.gls}{\PrintChanges}{\paragraph*{Change History} The list of changes goes here.\\Execute
+ \texttt{makeindex -s gglo.ist -o insdljs.gls insdljs.glo} on the command line and recompile
+ \texttt{insdljs.dtx}.}
+\end{document}
+%</driver>
+% \fi
+%
+% \InputIfFileExists{aebdonotindex.def}{\PackageInfo{insdljs}{Inputting aebdonotindex.def}}
+% {\PackageInfo{insdljs}{aebdonotindex.def cannot be found}}
+%
+% \section{Introduction}
+% This package defines a new environment, \texttt{insDLJS}, used
+% for inserting Acrobat JavaScript into a PDF file created from a
+% \LaTeX{} source. This package works correctly for users of
+% \textsf{pdftex} or \textsf{dvipdfm}. For those that use the
+% \textsf{Acrobat Distiller} (specifically, those that use either
+% \textsf{dvips} or \textsf{dvipsone} to produce a postscript file,
+% which is then distilled), you are required to have Acrobat~5.0 (or
+% later).
+%
+% \section{Features of the \textsf{insdljs} package}
+% We present a few of the several features of the package to get some feel for its
+% purpose.
+%
+% \subsection{The \texttt{insDLJS} Environment}
+%
+% The following is a quick illustration of the use of the new environment.
+% \begin{verbatim}
+% \documentclass{article}
+% \usepackage[pdftex]{hyperref}
+% \usepackage[pdftex]{insdljs}
+%
+% \newcommand\tugHello{Welcome to TUG 2001!}
+%
+% \begin{insDLJS}[HelloWorld]{mydljs}{My Private DLJS}
+% function HelloWorld()
+% {
+% app.alert("\tugHello", 3);
+% }
+% \end{insDLJS}
+% \begin{document}
+% \begin{Form} % needed for \PushButton
+%
+% \section{Test of the \texttt{insDLJS} Package}
+%
+% % use built in form button of hyperref
+% Push \PushButton[name=myButton,
+% onclick={HelloWorld();}]{Button}
+%
+% \end{Form}
+% \end{document}
+% \end{verbatim}
+% This environment takes three parameters, the first of which is required
+% for users of \texttt{dvips} and \texttt{dvipsone} and optional otherwise.
+% Within the environment, `|\|', is the escape character, and `|%|' is the comment
+% character, as they are in \TeX{} and \LaTeX.
+% See the documentation preceding the definition of the
+% \texttt{\hyperlink{insDLJS}{insDLJS}} environment.
+%
+% \subsection{Debugging}
+%
+% Another feature of this package is the ability to place debugging markers
+% within the JavaScript. When the \texttt{debug} option is used, the markers
+% show up in the document level JavaScript; otherwise, they are not written
+% to the PDF document. Here is a simple example,
+% \begin{verbatim}
+%\begin{insDLJS}[HelloWorld]{mydljs}{My Private DLJS}
+%function HelloWorld()
+%{
+% app.alert("\tugHello", 3);
+% var x = "\\";
+%\db console.println("Entered HelloWorld function and x = " + x);\db%
+%}
+%\end{insDLJS}
+%\end{verbatim}
+% The last line of the function will appear in the DLJS if compiled under
+% the \texttt{debug} option; otherwise, it is removed. Additional discussion
+% of this debugging device is given below.
+%
+% \subsection{Open Action}
+%
+% This package also defines an \cs{OpenAction} command to introduce actions that are
+% executed when the PDF document is opened on page~1. The open action command only
+% applies to page~1.
+% \begin{flushleft}
+% \textbf{Usage}
+%\begin{verbatim}
+%\OpenAction{/S/JavaScript/JS(app.alert("Hello World!");)}
+%\end{verbatim}
+% \end{flushleft}
+% The package defines a |\JS| that takes one argument. The code |\JS{#1}| expands to
+% |/S/JavaScript/JS (#1)|, and so the above example may be written as
+% \begin{flushleft}
+%\begin{verbatim}
+%\OpenAction{\JS{app.alert("Hello World!");}}
+%\end{verbatim}%
+%\end{flushleft}
+% Multiple JavaScript commands can be entered. For nice formatting use \cs{r}
+% and \cs{t} for carriage return and tab, respectively.
+%\goodbreak
+%\begin{verbatim}
+%\OpenAction{\JS{%
+% app.alert("Hello World!");\r
+% app.alert("Good Day to You!");
+%}}
+%\end{verbatim}
+% The open actions are placed in a token list. Additional actions are added to the token list, so
+% you say
+%\begin{verbatim}
+%\OpenAction{\JS{app.alert("Hello World!");}}
+%\OpenAction{\JS{app.alert("Good Day to You!");}}
+%\end{verbatim}
+% the two messages will appear each time you open page~1 of the document.
+%
+% In the case of users of the distiller, \textsf{insdljs} uses this mechanism to
+% define an open action. To avoid overwriting this definition, the \cs{OpenAction}
+% command is necessary in insert additional actions.
+%
+% See \Nameref{openaction} for more details.
+%
+% \subsection{How \textsf{insdljs} Works}
+%
+% Let me describe in rough terms what goes on behind the scenes. In the discussion
+% below, the following example will be used:
+%\begin{verbatim}
+%\newcommand\tugHello{"Hello World!"}
+%\begin{insDLJS}[HelloWorld]{mydljs}{My Private DLJS}
+%function HelloWorld()
+%{
+% app.alert("\tugHello", 3);
+%}
+%\end{insDLJS}
+%\end{verbatim}
+%
+% \subsubsection{For the \texttt{pdftex} and \texttt{dvipdfm} Options}
+%
+% Both \texttt{pdftex} and \texttt{dvipdfm} have primitives/macros for inserting
+% JavaScript at the document level into the PDF document. The work of the package,
+% in this case, is to take the JavaScript and place it into the correct form
+% for the application (\textsf{pdftex} or \textsf{dvipdfm}).
+%
+% Material within the \texttt{insDLJS} environment is written verbatim to a file.
+% The name of this file is \texttt{mydljs.djs}. The file base name comes from the
+% first required parameter of the \texttt{insDLJS} environment, see example above.
+% The file extension \texttt{.djs} stands for ``define javascript''.
+%
+% At begin document, the file \texttt{mydljs.djs} is input back into the document after
+% special definitions have already been read. These special definitions are the content
+% of the file \texttt{dljscc.def}. The script is placed in the appropriate construct
+% for insertion by the application at the document level.
+%
+% For more information about \texttt{dljscc.def}, see documentation given in the Section~\ref*{dljscc},
+% \Nameref{dljscc}.
+%
+% \subsubsection{For the \texttt{dvipsone} and \texttt{dvips} Options}
+%
+% When you use the \texttt{dvipsone} or \texttt{dvips}, this means you are going to convert
+% your document to postscript and distill it to create a PDF document. There is no \texttt{pdfmark}
+% construct for inserting document level JavaScripts; however, the recent release of Acrobat~5.0
+% gives postscript users an avenue for inserting DLJS.
+%
+% The material within the \texttt{insDLJS} environment is written verbatim to the file
+% \texttt{mydljs.djs}, as above. It is input back into the document where macros are allowed
+% to expand, then written back out to another file. The name of this new file is \texttt{mydljs.fdf}.
+% The file base name comes from the first required parameter of the \texttt{insDLJS} environment.
+% The file extension \texttt{.fdf} stands for ``forms data format''. This is an extension defined
+% and recognized by the Acrobat line of products.
+%
+% The file \texttt{mydljs.fdf} contains the document level JavaScript in a form that
+% the Acrobat application (version~5.0 or later) can import. Part of the work of the package
+% is to define an open page action. When the PDF document is opened for the first time in
+% Acrobat, the JavaScript is imported. Usually, you open the document following distillation.
+% After the \texttt{.fdf} file(s) have been imported, you need to save the document, usually using
+% the ``SaveAs'' file option, this saves the JavaScript code with the file. (There is no need for the
+% \texttt{.fdf} file(s) at this point.)
+%
+% \subsection{Comments on JavaScript}
+% A few words on JavaScript.
+%
+% \subsubsection{What is Document Level JavaScript?}
+% The document level is a location in the PDF document where script can be stored.
+% When the PDF document is opened, the document level functions are scanned, and any
+% ``exposed script'' is executed.
+%
+% Normally, the type of scripts you would place at the document level are
+% general purpose JavaScript functions, functions that are called repeatedly or large special
+% purpose functions. Functions at the document level
+% are known throughout the document, so they can be called by links, form buttons, page open
+% actions, etc.
+%
+% Variables declared within a JavaScript function have local scope, they are not known outside
+% that function. However, if you can declare variables and initialize them at the document level outside
+% of a function, these variables will have document wide scope. Throughout the document, the values of these
+% global variables are known. For example
+%\begin{verbatim}
+%\begin{insDLJS}[HelloWorld]{mydljs}{My Private DLJS}
+%var myVar = 17; // defined outside a function, global scope
+%function HelloWorld()
+%{
+% var x = 3; // defined inside a function, local scope
+% app.alert("\tugHello", 3);
+%}
+% \end{insDLJS}
+%\end{verbatim}
+% Both the function \texttt{HelloWorld()} and the variable \texttt{myVar} are known throughout
+% the document. The function \texttt{HelloWorld()} can be called by a mouse up button action;
+% some form field, executing some JavaScript, may access the value of \texttt{myVar} and/or
+% change its value. The variable \texttt{x} is not known outside of the \texttt{HelloWorld()} function.
+%
+% \subsubsection{Access and Debugging}
+% For those who do not have \textsf{Acrobat}, the application,
+% unless you are writing very simple code, writing and debugging
+% JavaScript will be very difficult. From the Acrobat Reader,
+% there is not access to the document level JavaScript. You will be
+% pretty much writing blind. You can use the debug feature of
+% \textsf{insdljs} and insert some debugging code to try to give you
+% some insight into what is going wrong. Even so, debugging will be a problem.
+%
+% Normally, I develop the JavaScript from within Acrobat. The GUI editor does check for
+% syntax errors, giving you a chance to correct some simple errors as you go. After I am satisfied
+% with my code, I copy it from the editor and paste it into a \texttt{insDLJS} environemnt. This is
+% how the JavaScript code of \textsf{exerquiz} was developed.
+%
+% In my opinion, if you want to develop rather complicated code, having the full Acrobat product
+% is a must. (This implies that the Windows or Mac platform is needed!)
+%
+% \subsubsection{JavaScript References}
+% The JavaScript used by Acrobat consists of the core JavaScript plus Acrobat's JavaScript extensions.
+% Acrobat~5.0 uses core JavaScript~1.5, see
+%\begin{quote}
+% \footnotesize\url{https://developer.mozilla.org/en/JavaScript}
+%\end{quote}
+% and documentation of the Acrobat extensions can be found in the ``JavaScript for Acrobat API Reference,''
+% see
+%\begin{quote}
+%\href{http://livedocs.adobe.com/acrobat_sdk/9.1/Acrobat9_1_HTMLHelp/wwhelp/wwhimpl/common/html/wwhelp.htm?context=Acrobat9_HTMLHelp&file=JS_API_AcroJSPreface.87.1.html}
+%{JavaScript for Acrobat API Reference}
+%\end{quote}
+%
+% \subsection{The \textsf{execJS} Environment}
+% This is an environment useful to PDF developers who want to tap into the power of JavaScript.
+% To use this environment, the developer needs Acrobat~5.0 or higher, or Acrobat Approval~5.0
+% or higher. \textsf{pdftex} or \textsf{dvipdfm} can be used to produce the PDF document, but one of the
+% applications (not the Reader) listed above is needed for this environment to do anything.
+%
+% The \texttt{execJS} is used primarily for post-distillation processing (post-creation processing, in the case of
+% \textsf{pdftex} and \textsf{dvipdfm}). The \texttt{execJS} environment can be used, for example, to automatically import
+% named icons into the document, which can, in turn, be used for an animation.
+%
+% The \textsf{execJS} is an environment in which you can write verbatim JavaScript code. This environment
+% is a variation on \textsf{insdljs}, it writes a couple of auxiliary files to disk; in particular, the
+% environment creates an \texttt{.fdf} file. When the newly produced PDF is loaded for the first time
+% into the viewer (Acrobat or Approval, not Reader), the \texttt{.fdf} file generated by the \textsf{execJS}
+% environment is imported, and the JavaScript executed. This JavaScript is \emph{not} saved with
+% the document.
+%
+% The environment takes one required argument, the base name of the auxiliary files to be generated.
+%
+%
+% For more details on this environment, see
+% \Nameref{execJS}. Also, see the demo file \texttt{execjstst.tex} and \texttt{execjstst.pdf} for
+% a short tutorial on the \texttt{execJS} environment, and an animation example, built entirely from
+% {\LaTeX} commands.
+%
+% \paragraph*{Security Note:} Executing arbitrary
+%JavaScript through a menu is potentially a security hole. If a
+%malicious hacker knows that you have a menu item with the name of
+%\texttt{MenuProc}, and that you use the variable
+%\texttt{\_MenuProc} in the way described above, the hacker could
+%distribute a PDF that executes (security restricted) JavaScript
+%through the menu in this way. Therefore, you should select
+%\texttt{private names} for \texttt{MenuProc} and \texttt{\_MenuProc}.
+%
+% \subsection{The \textsf{defineJS} Environment}
+%
+%When you create a form element (button, text field, etc.), you sometimes want to attach
+%JavaScript. The \textsf{defineJS} environment aids you in writing your Field level JavaScript.
+%It too is a verbatim environment, however, this environment does not write to this, but
+%saves the contents in a token register. The contents of the register are used in defining
+%a macro that expands to the verbatim listing.
+%
+% The \textsf{defineJS} environment takes two parameters, the first optional.
+% the required parameter is the cmd name of the command you want to define.
+% You can use the optional first parameter to modify the verbatim environment,
+% as illustrated. The \textsf{defineJS} is a complete verbatim environment: no escape,
+% and no comment characters are defined. You can use the optional parameter to create
+% an escape character. You can pretty much use any character you wish, \emph{except}
+% the usual one `\verb+\+', backslash.
+%
+% The following environment, defines a command \cs{myCmd} what expands to the verbatim
+% contents of the environment.
+%\begin{verbatim}
+%\begin{defineJS}{\myCmd}
+% ...
+% <JavaScript code>
+% ...
+%\end{defineJS}
+%\end{verbatim}
+%
+% There is also a \textsf{localJS} environment that makes any definitions within the
+% environment local.
+%
+%The following examples uses some macros from the \textsf{eforms} package:
+%\begin{verbatim}
+% % Define a text macro that will be expanded from within the
+% % defineJS environment
+%\def\HelloWorld{Hello World}
+% % Now define some JavaScript to execute with a button to be created.
+% % We enclose the defineJS and the \pushButton in the localJS environment
+% % That way, the macro definitions, \JSA, \JSAAE, \JSAAX will be local to
+% % this group
+%\begin{localJS}
+% % Make @ the escape so we can demonstrate the optional parameter.
+%\begin{defineJS}[\catcode`\@=0\relax]{\JSA}
+%var sum = 0;
+%for (var i = 0; i < 10; i++)
+%{
+% sum += i;
+% console.println("@HelloWorld i = " + i );
+%}
+%console.println("sum = "+sum);
+%\end{defineJS}
+%\begin{defineJS}{\JSAAE}
+%console.println("Enter the button area");
+%\end{defineJS}
+%\begin{defineJS}{\JSAAX}
+%console.println("Exiting the button area");
+%\end{defineJS}
+%\pushButton[%
+% \A{\JS{\JSA}}
+% \AA{\AAMouseEnter{\JS{\JSAAE}}
+% \AAMouseExit{\JS{\JSAAX}}}
+%]{myButton}{30bp}{15bp}
+%\end{localJS}
+%\end{verbatim}
+%
+% See the section \Nameref{defineJS} for details of these two environments.
+% \section{Package Options and Requirements}
+%
+% \subsection{Package Options}
+%
+% The options are \texttt{dvipsone}, \texttt{dvips}, \texttt{pdftex} and
+% \texttt{dvipdfm}. The default is \texttt{dvipsone}/\texttt{dvips}.
+% \begin{macrocode}
+%<*package>
+\usepackage{xkeyval}
+\RequirePackage{ifpdf}[2006/02/20]
+\RequirePackage{ifxetex}[2006/08/21]
+% \end{macrocode}
+%
+% Standard driver options.\par\medskip\noindent
+% \textbf{Those using Distiller}
+% \IndexOpt{dvips}
+% \IndexOpt{dvipsone}
+% \IndexOpt{textures}
+% \begin{macrocode}
+\DeclareOptionX{dvipsone}{\def\dljs@drivernum{0}%
+ \AtBeginDocument{\dvips@marker}}
+\DeclareOptionX{dvips}{\def\dljs@drivernum{0}%
+ \AtBeginDocument{\dvips@marker}}
+\DeclareOptionX{textures}{\def\dljs@drivernum{0}%
+ \AtBeginDocument{\dvips@marker}}
+% \end{macrocode}
+%\textbf{Those not using Distiller}
+% \IndexOpt{pdftex}
+% \IndexOpt{dvipdfm}
+% \IndexOpt{dvipdfmx}
+% \IndexOpt{xetex}
+% \begin{macrocode}
+\DeclareOptionX{pdftex}{\def\dljs@drivernum{1}}
+\DeclareOptionX{dvipdfm}{\def\dljs@drivernum{2}}
+\DeclareOptionX{dvipdfmx}{\def\dljs@drivernum{2}}
+\DeclareOptionX{xetex}{\def\dljs@drivernum{2}}
+% \end{macrocode}
+% Set the default value of the driver: assume the distiller is used.
+% \begin{macrocode}
+%\def\dljs@drivernum{0}
+% \end{macrocode}
+% Some switch definitions
+% \begin{macrocode}
+\let\dl@YES=y \let\dl@NO=n
+\let\dl@One=1 \let\dl@Zero=0
+\let\dljs@YES=y \let\dljs@NO=n
+% \end{macrocode}
+% When using pdfmarks, the open action is initiated by the document JavaScript code,
+% when there was not document JavaScript, the open action did not get executed.
+% This was a bad idea, here is a work around. When the \texttt{insDLJS} environment is used,
+% we |\let\dljspresent=y|, and if at the beginning of the document, \cs{dljspresent} is still
+% \texttt{n}, we'll issue a special execution of \cs{@OAction}.
+% \begin{macrocode}
+\def\dvips@marker{\ifx\dljspresent\dl@NO\@OAction\fi}
+% \end{macrocode}
+% This command sequence will mark the passing of the first open event that is defined. The rest of the open events,
+% if any, will be in a \texttt{Next} dictionary.
+% \begin{macrocode}
+\let\isOpenAction\dl@NO
+% \end{macrocode}
+% \IndexOpt{nodljs}
+% Option to cancel the insertion of DLJS, useful for a document meant to be
+% printed only, or one that does not use the \texttt{shortquiz} or
+% \texttt{quiz} environments, for example.
+% \begin{macrocode}
+\DeclareOptionX{nodljs}{\let\importdljs\dl@NO}
+\let\importdljs\dl@YES
+% \end{macrocode}
+% Need to place certain code only once. This switch will make sure of that.
+% \begin{macrocode}
+\let\firstdljs\dl@YES
+\let\dljspresent\dl@NO
+% \end{macrocode}
+% \IndexOpt{debug}
+% Use this option to help debug DLJS.
+% \begin{macrocode}
+\DeclareOptionX{debug}{\let\dljs@debug\dl@YES}
+\let\dljs@debug\dl@NO
+% \end{macrocode}
+% \IndexOpt{execJS}
+% If the execution of JavaScript code is permitted following distillation. The default is no.
+% \begin{macrocode}
+\DeclareOptionX{execJS}{\let\execjs\dl@YES}
+\let\execjs\dl@NO
+\DeclareOptionX{nopro}{\let\dl@gopro\dl@NO}
+\let\dl@gopro\dl@YES
+% \end{macrocode}
+% \begin{macrocode}
+\@ifpackageloaded{web}{%
+ \ExecuteOptionsX{\eq@driver@name}%
+}{%
+ \@ifpackageloaded{eforms}{%
+ \ExecuteOptionsX{\ef@driver}%
+ }{%
+ \ifpdf\ExecuteOptionsX{pdftex}\else
+ \ifxetex\ExecuteOptionsX{xetex}\else
+ \@ifundefined{l@tex@@@@driver}{\ExecuteOptionsX{dvips}}
+ {\ExecuteOptionsX{dvipsone}}\fi\fi
+ }%
+}
+% \end{macrocode}
+% \IndexOpt{reqjs}
+% Beginning with PDF 1.7, a document can specify requirements, here we declare
+% the document uses JavaScripts. The option \texttt{reqjs} is taken by default,
+% that is, JavaScripts are required for this document
+%
+% \DescribeMacro{!reqjs}
+% The option \texttt{!reqis} turns off this feature; that is, there is no notification
+% via the \textsf{YMB} (\textsf{Yellow Message Bar}) that Javascripts are used in the document, and the
+% document may not function as designed.
+% \changes{v2.2d}{2016/04/06}{Added \texttt{reqjs} and \texttt{{\string\quotechar}reqjs}.}
+% \begin{macrocode}
+\DeclareOptionX{reqjs}{\let\dl@reqJS\dl@YES}
+\let\dljs@reqJS\dl@YES
+\DeclareOptionX{!reqjs}{\let\dl@reqJS\dl@NO}
+% \end{macrocode}
+% The \texttt{usealtadobe} option\IndexOpt{usealtadobe} defined alternate names
+% for some of Adobe's formatting functions. This is useful only if the document
+% author has the Adobe application and know how to use its form edit capabilities.
+% The name of each of the selected function begins with `\texttt{AF}', the name of the new
+% function is the same, but begins with `\texttt{EF}'. For example, the keystroke function
+% \texttt{AFNumber\_Keystroke} is also known under the name of \texttt{EFNumber\_Keystroke}.
+% See \hyperref[s:AltAdbFncs]{Section~\ref*{s:AltAdbFncs}} for the list of functions.
+% \begin{macrocode}
+\DeclareOptionX{usealtadobe}{\def\inputAltAdbFncs{%
+ \InputIfFileExists{altadbfncs.def}%
+ {\PackageInfo{insdljs}{Inputting code for usealtadobe option}}%
+ {\PackageWarning{insdljs}{Cannot find altadbfncs.def.\MessageBreak
+ Reinstall or refresh your file name database.}}}}
+\let\inputAltAdbFncs\relax
+% \paragraph*{Process the package options}
+% \begin{macrocode}
+\ProcessOptionsX
+% \end{macrocode}
+% This package uses the double quote as a double quote, other packages the make double quote
+% an active character.
+% \begin{macrocode}
+\edef\dl@dquoteCat{\the\catcode`\"}
+\catcode`\"=12\relax
+% \end{macrocode}
+% Issue a package error if there is no driver specified or implied.
+% \begin{macrocode}
+\@ifundefined{dljs@drivernum}{%
+ \PackageError{insdljs}%
+ {You have not specified dvips, dvipsone, pdftex,\MessageBreak
+ dvipdfm, dvipdfmx, or xetex in the option list
+ \MessageBreak of the insdljs package}
+ {Place one of the drivers dvips, dvipsone, pdftex, dvipdfm,
+ dvipdfmx, or xetex
+ \MessageBreak in the option list of the insdljs package.}
+}{}
+% \end{macrocode}
+% \subsection{Required Packages}
+% We need \texttt{hyperref} to provide some fundamental code for the
+% various drivers and \texttt{verbatim} to help write verbatim code
+% to a file.
+% \changes{v2.2h}{2016/06/09}{Added \string\cs{ifpdfmarkup} to easily detect
+% use of pdfmarks}
+% \begin{macrocode}
+\@ifundefined{ifpdfmarkup}{\newif\ifpdfmarkup}{}\pdfmarkupfalse
+\ifpdf\else\ifxetex\else\pdfmarkuptrue\fi\fi
+% \begin{macrocode}
+\RequirePackage{hyperref}
+% \end{macrocode}
+% LuaTeX v0.85 has made some changes to primitives, the definition below follows
+% the pattern of \texttt{hluatex.def} of \textsf{hyperref}.
+% \changes{v2.3}{2016/06/09}{Fixed \string\cs{pdfnames} corresponding to
+% changes in primitives of LuaTeX v0.85}
+% \changes{v2.3a}{2016/07/31}{Added luatex85 definition of \string\cs{pdfpageref}}
+% \begin{macrocode}
+\ifpdf\ifx\pdfextension\@undefined\else
+ \protected\def\pdfnames{\pdfextension names }
+ \def\pdfpageref{\pdffeedback pageref}\fi\fi
+\RequirePackage{verbatim}
+% \end{macrocode}
+% (2017/01/03) The \pkg{insdljs} package does not use \pkg{conv-xkv} but
+% is fundamental to other packages (\pkg{eforms}, \pkg{aeb\_pro}) that require
+% \pkg{insdljs} and \pkg{conv-xkv}.
+% \changes{v2.3c}{2017/01/03}{Require \string\pkg{conv-xkv}}
+% \begin{macrocode}
+\usepackage{conv-xkv}[2017/01/03]
+% \end{macrocode}
+% Last minute adjustments in the driver.
+% \begin{macrocode}
+\@ifundefined{dljs@drivernum}{%
+ \@ifundefined{eq@drivernum}{%
+ \PackageWarning{insdljs}
+ {No driver specified, will check for pdftex.}
+ \@ifundefined{pdfoutput}{%
+ \@ifundefined{@pdfm@mark}{\def\eq@drivernum{2}%
+ \def\dljs@drivernum{1}\let\isOpenAction\dl@NO
+ \PackageWarning{insdljs}{No pdftex, but detected dvipdfm}}%
+ {\PackageWarning{insdljs}{Neither pdftex nor dvipdfm,
+ assuming dvips/dvipsone.}%
+ \def\eq@drivernum{0}\def\dljs@drivernum{0}%
+ \let\isOpenAction\dl@YES}
+ }{%
+ \ifcase\pdfoutput
+ \def\eq@drivernum{1}\def\dljs@drivernum{1}%
+ \let\isOpenAction\dl@NO
+ \PackageInfo{insdljs}{Pdftex detected.}%
+ \else
+ \def\eq@drivernum{0}\def\dljs@drivernum{0}%
+ \let\isOpenAction\dl@YES
+ \PackageWarning{insdljs}{Pdftex engine detected,
+ but is outputting dvi. Assuming dvips as the driver.}%
+ \fi
+ }%
+ }{%
+ \begingroup
+ \count0=\eq@drivernum
+ \xdef\dljs@drivernum{\ifcase\count0 0\or1\or2\or0\else0\fi}
+ \ifnum\dljs@drivernum=0\global\let\isOpenAction\dl@YES
+ \else\global\let\isOpenAction\dl@NO\fi
+ \endgroup
+ }%
+}{}
+% \end{macrocode}
+% I've always had problems with the pdftex option and inserting open page actions.
+% The problem is that the open page action, which is defined using the token list
+% \cs{pdfpageattr} appears not only on the first page, but every page thereafter.
+% To solve this problem, I've used \textsf{everyshi}, a nice and useful package by
+% Martin Schr\"oder, to set the open page action with \cs{AtNextShipout}.
+% This approach seems to work.
+% \begin{macrocode}
+\ifnum\dljs@drivernum=1\relax
+ \RequirePackage{everyshi}
+\fi
+% \end{macrocode}
+% If \texttt{reqjs} is in effect, we execute the following code, otherwise, we
+% do not. The \textbf{\textsf{Requirements}} dictionary goes in the document \textbf{\textsf{Catalog}}.
+% \changes{v2.2d}{2016/04/06}{Code to support \texttt{reqjs} and \texttt{{\string\EXPT}reqjs} options.}
+% \begin{macrocode}
+\def\AEB@psMrk{[\space}
+\ifx\dl@reqJS\dl@YES
+ \def\dl@@reqJS{/Type/Requirement/S/EnableJavaScripts}
+ \ifpdf\pdfcatalog{\dl@@reqJS}\else
+ \ifxetex\immediate\@pdfm@mark{put @catalog <<\dl@@reqJS>>}\else
+ \literalps@out{\AEB@psMrk{Catalog} <<\dl@@reqJS>> /PUT pdfmark}\fi\fi
+\fi
+% \end{macrocode}
+% \section{Main Code}
+%
+% Before we begin, we need to document the problems that need to be addressed by this package.
+%
+% \subsection{Complications}
+%
+% There is a complication with writing JavaScript and \TeX{} together; they both use
+% the backslash character, `|\|', as the escape character. The following two tables
+% list escaped characters that have special meanings in different situations. These two tables
+% were taken from the book \textsl{JavaScript, The Definitive Guide}, by David Flanagan, 4th Edition,
+% O'Reilly publishers.
+%
+%\begin{flushleft}
+%\begin{minipage}{\linewidth}
+% \textbf{Escape Sequences in String Literals}
+%
+% \begin{tabular}{@{}ll@{}}
+% Sequence & Character represented \\
+% \cs{0} & the NULL character (\cs{u0000}) \\
+% \cs{b} & backspace (\cs{u0008}) \\
+% \cs{t} & horizontal tab (\cs{u0009}) \\
+% \cs{n} & newline (\cs{u000A}) \\
+% \cs{v} & vertical tab (\cs{u000B}) \\
+% \cs{f} & form feed (\cs{u000C}) \\
+% \cs{r} & carriage return (\cs{u000D}) \\
+% \cs{"} & double quote (\cs{u0022}) \\
+% \cs{'} & apostrophe or single quote (\cs{u0027}) \\
+% |\\| & backslash (\cs{u005C})\\
+% \cs{xXX} & the Latin-1 character specified by the two hexadecimal digits \texttt{XX} \\
+% \cs{uXXXX}& the unicode character specified by the four hexadecimal digits \texttt{XXXX} \\
+% \cs{XXX} & the Latin-1 character specified by the octal digits \texttt{XXX}, between \\
+% & $1$ and $377$. \\
+% \end{tabular}
+%\end{minipage}
+%\end{flushleft}
+%
+%\begin{flushleft}
+%\begin{minipage}{\linewidth}
+% \textbf{Regular Expression Literal characters}
+%
+% \begin{tabular}{ll}
+% Character & Matches \\
+% Alphanumeric & Itself \\
+% \cs{0} & the NULL character (\cs{u0000}) \\
+% \cs{t} & horizontal tab (\cs{u0009}) \\
+% \cs{n} & newline (\cs{u000A}) \\
+% \cs{v} & vertical tab (\cs{u000B}) \\
+% \cs{f} & form feed (\cs{u000C}) \\
+% \cs{r} & carriage return (\cs{u000D}) \\
+% \cs{xXX} & the Latin-1 character specified by the two hexadecimal\\
+% & digits \texttt{XX} \\
+% \cs{uXXXX}& the unicode character specified by the four hexadecimal\\
+% & digits \texttt{XXXX} \\
+% \cs{cXX} & the control character |^X|
+% \end{tabular}
+%\end{minipage}
+%\end{flushleft}
+%
+% Again, both JavaScript and \TeX, certain punctuation marks have special meaning; in the case of
+% JavaScript, punctuation has a special meaning within regular expressions:
+%\begin{flushleft}
+%\textbf{Special Punctuation in Regular Expressions}
+%\begin{verbatim}
+% ^ $ . * + ? = ! : | \ / ( ) [ ] { }
+%\end{verbatim}
+%\end{flushleft}
+%
+% Complications continued. The distiller method (the \texttt{dvipsone} or the
+% \texttt{dvips} option), and the \textsf{pdftex}/\textsf{dvipdfm} applications
+% handle the backslash differently. The following example illustrates the problem.
+% {\small
+%\begin{verbatim}
+%dvipsone/dvips
+%LaTeX Source As appears in PDF
+%var x = "\"; --> var x = "\"; (SyntaxError: Unterminated string literal)
+%var x = "\\"; --> var x = "\\"; (Correct)
+%\end{verbatim}}
+% When we type \texttt{"\string\"}, we are beginning a string (with the first
+% double quotes, but then we have a literal \texttt{\string\"}, so we have not
+% closed the opening string, hence the error message. We have to type
+% `\verb+\\+' to get the single backslash.
+% {\small
+%\begin{verbatim}
+%pdftex/dvipdfm
+%LaTeX Source As appears in PDF
+%var x = "\"; --> var x = ""; (\" is the literal ")
+%var x = "\\"; --> var x = "\"; (SyntaxError: Unterminated string literal)
+%var x = "\\\\"; --> var x = "\\"; (Correct)
+%\end{verbatim}}
+% These applications write raw PDF code to the \texttt{.pdf} file.
+% All special characters need to be escaped. You can see, that \textsf{pdftex}
+% and \textsf{dvipdfm} require extra backslashs.
+%
+% The solution to this problem---the problem of how distiller and the two applications
+% handle backslashes---is to define control sequences for all the sequences JavaScript uses
+% and to adjust their definitions depending on the driver option. As a result, of these
+% background definitions, the JavaScript writer does not worry too much about these details,
+% for example
+%\begin{verbatim}
+%\begin{insDLJS}[HelloWorld]{mydljs}{My Private DLJS}
+%function HelloWorld()
+%{
+% app.alert("\tugHello", 3);
+% var x = "\\";
+% app.alert("x = " + x);
+%}
+%\end{insDLJS}
+%\end{verbatim}
+% So much for the complication.
+%
+%\subsection{Begin Code}
+%
+% Some control sequences that are useful for formatting JavaScript.
+% \begin{macro}{\JS}
+% \begin{macro}{\Named}
+% A convenience command for writing JavaScript.
+% \begin{macrocode}
+\providecommand\JS[1]{/S/JavaScript/JS(#1)}
+\providecommand\Named[1]{/S/Named/N/#1}
+\providecommand{\GoTo}{/S/GoTo/D}
+\providecommand{\GoToD}{/S/GoTo/D}
+\providecommand{\GoToR}{/S/GoToR}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+% \begin{macrocode}
+\def\previewMiKTeX{\def\jsR{\string\r}\def\jsT{\string\t}}
+{\obeylines %
+\gdef\js@@R{\noexpand
+}}
+% \end{macrocode}
+% \begin{macrocode}
+\let\dljstfor\@tfor
+% \end{macrocode}
+% 2012/06/20 Change the following code so there are no special cases.
+% \begin{macrocode}
+\def\jsR{\string\r\string\n}
+%\def\jsR{\string\r\eqbs\js@@R}
+\def\defineJSjsR{\string\r\eqbs^^J}
+% \end{macrocode}
+% \changes{v2.0l}{2012/11/10}{Added \cs{jsN}}
+% \cs{r} is recognized by hyperref when \cs{pdfstringdef} is used. Hyperref
+% then modifies the expansion of \cs{r}. So, we'll use \cs{n} is those situations.
+% \begin{macrocode}
+\def\jsN{\string\n}
+{\catcode`\^^I\active %
+\gdef^^I{\noexpand^^I}%
+\gdef\js@@T{\noexpand^^I}%
+}% end of \catcode`\^^I
+\let\jsT=\js@@T
+% \end{macrocode}
+% Need to write to files. This stream will be used for that purpose.
+% \begin{macrocode}
+\newwrite\js@verbatim@out
+\def\iwvo#1{\immediate\write\js@verbatim@out{#1}}
+% \end{macrocode}
+% \subsection{Some JavaScript Support}
+%
+% \begin{macro}{\flJSStr}
+% \begin{macro}{\dlJSStr}
+%
+% A simple command for creating JavaScript strings that recognize unicode escape
+% sequences \cs{uXXXX}. This command defines a macro with name contained in \texttt{\#1},
+% the first argument, the second argument \texttt{\#2} is the JavaScript string. Enclosing
+% the string with double quotes is not necessary, this is done automatically. Any expandable
+% commands within string are expanded at define time, unless they are protected with \cs{protect}.
+% The string can be formatted using \cs{r} and \cs{t}. Also, \verb!\\! expands to a backslash
+% should the need arise.
+%\changes{v2.0b}{2008/06/19}
+%{
+% A simple command for creating JS strings with unicode \cs{uXXXX}.
+%}
+% The following is the old definition, it is superseded by the ones below.
+%\begin{verbatim}
+%\newcommand{\defineJSStr}[2]{{%
+% \let\protect\noexpand
+% \let\jslit\string
+% \def\\{\eqbs\eqbs}\def\cs##1{\\\\##1}%
+% \def\r{\\r}\def\t{\\t}%
+% \def\n{\\n}\def\u{\\u}%
+% \xdef#1{"#2"}%
+%}}
+%\end{verbatim}
+% \changes{v2.0m}{2013/12/23}{Added \cs{jscsDflt} and \cs{jscsDLJS}, incorporated into \cs{dl@defJSStr}.}
+% Added \cs{jscsDflt} and \cs{jscsDLJS}, incorporated them into \cs{dl@defJSStr}.
+% \begin{macrocode}
+\def\dl@lparen{(}\def\dl@rparen{)}
+\def\jscsDflt{\let\protect\noexpand\let\jslit\string
+ \let\~\dl@tilda\let\^\dl@sup
+ \def\\{\eqbs\eqbs}\def\cs##1{\\\\##1}%
+ \def\r{\\r}\def\t{\\t}\def\n{\\n}%
+ \let\{\dl@lBrace\let\}\dl@rBrace
+ \ifx\jsstr@useUni\dl@One\def\Uni{\\u}\else\def\u{\\u}\fi
+ \ifx\jsstr@parens\dl@One\let\l@paren\dl@lparen
+ \let\r@paren\dl@rparen\else
+ \let\l@paren\@empty\let\r@paren\@empty\fi
+}
+\def\jscsDLJS{\let\protect\noexpand\let\jslit\string
+ \let\~\dl@tilda\let\^\dl@sup
+ \ifxetex\def\\{\eqbs\eqbs}\else\def\\{\eqbs}\fi\def\cs##1{\\\\##1}%
+ \def\r{\\r}\def\t{\\t}\def\n{\\n}%
+ \let\{\dl@lBrace\let\}\dl@rBrace
+ \ifx\jsstr@useUni\dl@One\def\Uni{\\u}\else\def\u{\\u}\fi
+ \ifx\jsstr@parens\dl@One\let\l@paren\dl@lparen
+ \let\r@paren\dl@rparen\else
+ \let\l@paren\@empty\let\r@paren\@empty\fi
+}
+\ifpdf\let\jscsDLJS\jscsDflt\fi
+\let\dl@JSCS\jscsDflt
+% \end{macrocode}
+% \DescribeMacro{\flJSStr} This form is designed for writing literal strings
+% at the field level.
+% When the \texttt{*}-form is used, \texttt{\#2} is passed through \cs{pdfstringdef},
+% needed if there are some latex to pdf strings to be converted.
+% \begin{macrocode}
+\newcommand{\flJSStr}{\bgroup
+ \let\dl@JSCS\jscsDflt
+ \@ifstar{\def\isStar{*}\dl@defJSStr}
+ {\let\isStar\relax\dl@defJSStr}}
+\let\fieldJSStr\flJSStr
+% \end{macrocode}
+% For backward compatibility, we \cs{let} \cs{defineJSStr} to \cs{flJSStr}.
+% \begin{macrocode}
+\let\defineJSStr\flJSStr
+% \end{macrocode}
+% \DescribeMacro{\dlJSStr} This form is designed for writing strings to the document
+% level JavaScript, as embedded using the \texttt{insDLJS} environment.
+% When the \texttt{*}-form is used, \texttt{\#2} is passed through \cs{pdfstringdef},
+% needed if there are some latex to pdf strings to be converted.
+% \begin{macrocode}
+\newcommand{\dlJSStr}{\bgroup
+ \@ifstar{\def\isStar{*}\let\dl@JSCS\jscsDLJS\dl@defJSStr}
+ {\let\isStar\relax\let\dl@JSCS\jscsDLJS\dl@defJSStr}}
+% \end{macrocode}
+% Some simple key-values for both commands above. Both commands, by default,
+% insert double quotations marks at the beginning and end of the string as a convenience.
+% \IndexKey{quotes}\texttt{quotes} option just affirms that default; it need not be specified.
+% The \IndexKey{noquotes}\texttt{noquotes} option signals \textsf{eforms} not to
+% insert said double quotation marks. The other option, \texttt{useUni} is implemented, but not
+% documented publicly, to change the command for unicode from \cs{u} to \cs{Uni} in case there
+% is a clash of definitions with some accents, \u{a} (\verb!\u{a}!), for example. Hyperref has a
+% \cs{u} command defined in the PU encoding, but \cmd{\flJSStr} and \cmd{\dlJSStr} through
+% \cmd{\dl@defJSStr} sets \cmd{\Hy@unicodefalse} to support PD1 encoding only. The user can
+% access the full range of unicode glyphs through \cs{u}.
+% \begin{macrocode}
+\define@key{jsstr}{quotes}[]{\let\jsstr@quotes\dl@One}
+\define@key{jsstr}{noquotes}[]{\let\jsstr@quotes\dl@Zero}
+\define@key{jsstr}{parens}[]{\let\jsstr@parens\dl@One}
+\define@key{jsstr}{noparens}[]{\let\jsstr@parens\dl@Zero}
+\let\jsstr@quotes\dl@One\let\jsstr@parens\dl@One
+\define@key{jsstr}{useUni}[]{\let\jsstr@useUni\dl@One}
+\let\jsstr@useUni\dl@Zero
+% \end{macrocode}
+% The common part to both \cs{flJSStr} and \cs{dlJSStr}.
+% \begin{macrocode}
+\newcommand{\dl@defJSStr}[3][quotes]{\def\dl@argi{#1}\ifx\dl@argi\@empty
+ \else\ifx\dl@JSCS\jscsDLJS\let\jsstr@parens\dl@Zero\fi
+ \setkeys{jsstr}{#1}\fi\dl@JSCS
+ \ifx\jsstr@quotes\dl@One
+ \xdef#2{\l@paren"#3"\r@paren}\else
+ \xdef#2{\l@paren#3\r@paren}\fi
+ \if\isStar*\gdef\dl@afterAction{{\Hy@unicodefalse\expandafter
+ \pdfstringdef\expandafter#2\expandafter{#2}}}\else
+ \global\let\dl@afterAction\relax\fi
+ \aftergroup\dl@afterAction\egroup}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+% \begin{macro}{\dlTC}\hspace{-\marginparsep}\thinspace
+% \darg{\ameta{code}} A convenience command to insert a \texttt{try/catch} pair around
+% \ameta{code} with no error report.
+% \changes{v2.3e}{2017/02/27}{Added convenience command \string\cs{dlTC}}
+% \begin{macrocode}
+\def\dlTC#1{try{#1}catch(e){}}
+% \end{macrocode}
+% \end{macro}
+%
+% \subsection{A Macro for Debugging JS}
+% \begin{macro}{\db...\db}
+% The \cs{db} macro can be used within the \texttt{insDLJS} to insert
+% addition JS commands to help debug the code. Usage:
+%\begin{verbatim}
+% \db console.println("myVal = " + myVal);\db%
+%\end{verbatim}
+% Any material (on one line) that is between the two \verb+\db+ will either be
+% written to the DLJS (if \cmd{\dljs@debug} expands to \texttt y), or be removed from
+% the final output (if \cmd{\dljs@debug} does not expand to \texttt y).
+%
+% Note that the comment character (|%|) following the terminating \verb+\db+.
+% This comment keeps a carriage return from being invoked; if \cmd{dljs@debug} is false
+% then this will not create an empty line in your JavaScript.
+% \begin{macrocode}
+\def\js@R{\ifcase\dljs@drivernum^^J\else\jsR\fi}
+% \end{macrocode}
+% The three spaces (\cs{space}) is meant to align the debug statement, since |\db| takes
+% up three spaces.
+% \begin{macrocode}
+\def\db#1\db{\ifx\dljs@debug\dl@YES\space\space\space#1\js@R\fi}
+% \end{macrocode}
+% \end{macro}
+% Acrobat (and Reader) expect the JavaScript code will be listed in the JavaScript
+% array in sorted form. \texttt{pdftex} and \texttt{dvipdfm} do not sort this array
+% and it would be difficult for \TeX{} to do the sorting; therefore a workaround.
+% Each set of DLJS will be numbered in the order in which they are defined. This puts
+% them naturally in proper sorted order. The following counter, numbers the JS.
+% \begin{macrocode}
+\newcounter{dljs@cnt}
+\newcounter{dljssegs}\setcounter{dljssegs}{2}
+% \end{macrocode}
+% \subsection{Some Verbatim Write Environments}
+% Here is a verbatim write environment, based on an example in the
+% \texttt{verbatim} package. One modification: The output stream is
+% not opened by this environment, this must be done prior. This is necessary
+% to write some other stuff prior to the verbatim write.
+%
+% This verbatim is used internally to write the \texttt{.djs} files, containing
+% the JavaScript.
+% \begin{macrocode}
+\newenvironment{js@verbatimwrite}% writes to current \js@verbatim@out
+ {%
+ \@bsphack
+ \let\do\@makeother\dospecials\catcode`\^^M\active
+ \def\verbatim@processline{%
+ \immediate\write\js@verbatim@out{\the\verbatim@line}}%
+ \verbatim@start}{\@esphack}
+% \end{macrocode}
+% Unlike the example of verbatimwrite in the \texttt{verbatim} package, we do not
+% automatically close the stream when we finish out \texttt{js@verbatimwrite} environment.
+% We need to write more to this file, so we have an explicit close.
+% \begin{macrocode}
+\def\closejs@verbatim@out{\immediate\closeout\js@verbatim@out}
+% \end{macrocode}
+% Same as above, except we expand the line with an \cmd{\edef}.
+%
+% For the case of \texttt{dvipsone/dvips}, which use the pdfmark operator, we have
+% a couple of definitions for escape (esc). It turns out, I find it convenient to have
+% two versions, a \cs{eqesc}, and a \cs{eqesci}, the latter one is only used once, the former
+% one is used numerous times, see the \texttt{\hyperref[dljscc]{dljscc.def}} file.
+% \begin{macrocode}
+\begingroup
+\catcode`\@=0 @catcode`@\=12
+@gdef@eqbs{\}
+@gdef@ccpdfmark{@gdef@eqesc{\}@gdef@eqesci{}}
+@endgroup
+% \end{macrocode}
+% Here's a definition of left and right braces that will be used in writing JavaScript code.
+% \begin{macrocode}
+\begingroup
+ \catcode`<=1 \catcode`\>=2 \@makeother\{ \@makeother\}
+\gdef\definebraces<\def\{<\eqesc{>\def\}<\eqesc}>>
+\endgroup
+% \end{macrocode}
+% My own special dos and don'ts. Preserve |\| and \texttt{\%}
+% \begin{macrocode}
+\def\eqdospecials{\do\ \do\{\do\}\do\$\do\&%
+ \do\#\do\^\do\_\do\~}
+% \end{macrocode}
+% The \texttt{jsexpverbatimwrite} environment is used to write a quasi-verbatim
+% file. We keep original default definitions of |\| and |%| (they are not included in the
+% \cs{eqdospecials} above). The code for \texttt{jsexpverbatimwrite} is based on that found
+% in the \texttt{verbatim} package. The trouble is, this package assumes that |\| has been changed
+% to catcode 12, other. Consequently, I had a devil of a time trying to stop the verbatim write
+% with |\| as an escape rather than other. I finally decided it was necessary to rewrite some of
+% the main macros in \texttt{verbatim} so they would properly stop. Below are the modifications
+% designed to stop when \texttt{*end} encountered rather than \cs{end}. These changes seem to
+% work o.k.
+% \begin{macrocode}
+\begingroup
+\catcode`\~=\active \lccode`\~=`\^^M
+\lowercase{\endgroup
+ \def\eqverbatim@#1~{\verbatim@@#1*end\@nil}%
+ \def\eqverbatim@@#1*end{%
+ \verbatim@addtoline{#1}%
+ \futurelet\dl@next\eqverbatim@@@}%
+ \def\eqverbatim@@@#1\@nil{%
+ \ifx\dl@next\@nil
+ \verbatim@processline
+ \verbatim@startline
+ \let\dl@next\eqverbatim@
+ \else
+ \def\@tempa##1*end\@nil{##1}%
+ \@temptokena{*end}%
+ \def\dl@next{\expandafter\verbatim@test\@tempa#1\@nil~}%
+ \fi\dl@next}%
+}%
+\def\jsexpverbatimwrite
+{% writes to current \js@verbatim@out
+ \@bsphack
+% \escapechar=-1%
+ \ccpdfmark
+ \catcode`\<=12 \catcode`\>=12
+ \input{dljscc.def}%
+% Attempt to redefine some macros from the the verbatim package
+ \let\verbatim@=\eqverbatim@
+ \let\verbatim@@=\eqverbatim@@
+ \let\verbatim@@@=\eqverbatim@@@
+% end redefine of verbatim package
+ \let\do\@makeother\eqdospecials%
+ \catcode`\^^M=\active\catcode`\^^I=12%
+ \def\verbatim@processline{%
+ \edef\expVerb{\the\verbatim@line}%
+ \immediate\write\js@verbatim@out{\expVerb}}%
+ \verbatim@start%
+}
+\def\endjsexpverbatimwrite{\immediate\closeout\js@verbatim@out\@esphack}
+% \end{macrocode}
+% \begin{macro}{\insPath}
+% Set this macro in the \textbf{preamble} of your document to
+% direct (almost) all auxiliary files of insDLJS to the specified
+% path. The macro takes one parameter, a path on your local hard
+% disk. Usage:
+%\begin{verbatim}
+%\insPath{c:/temp/}
+%\end{verbatim}
+% Be sure to use only forward slashes, and don't forget to finish
+% the string with a final forward slash, as illustrated above.
+%
+% All \texttt{*.fdf} files are written to this folder. The
+% \texttt{.djs} files of any \texttt{insDLJS} environments created
+% after the \cmd{\insPath} will also be written to the path. Any
+% \texttt{.djs} created by packages loaded earlier (such as
+% \textsf{exerquiz}) will be written to the current directory.
+%
+% This macro may be useful for users of Distiller~5.0, and is of marginal
+% value to users of \textsf{pdftex/dvipdfm}.
+% \begin{macrocode}
+\let\js@Path\@empty
+\def\insPath#1{\def\js@Path{#1}}
+% \end{macrocode}
+% \end{macro}
+% \DescribeMacro{\makeJSspecials}
+% This command is typically executed at the beginning of each field
+% or link (see \cs{eq@setButtonProps} and \cs{eq@setWidgetProps}).
+% They are used for formatting JavaScript code. The command
+% \cs{makespecialJS} is defined in \textsf{insdljs}.
+% \changes{v2.1}{2015/06/15}{Moved \cs{makeJSspecials} from \textsf{eforms}
+% to here.}
+% \begin{macrocode}
+\begingroup
+\catcode`\{=12 \catcode`\}=12 \catcode`\<=1 \catcode`\>=2
+\gdef\dl@lBrace<\string\{> \gdef\dl@rBrace<\string\}>
+\gdef\dl@tilda<\string~> \gdef\dl@sup<\string^>
+\endgroup
+\def\makeJSspecials{%
+ \def\\{\eqbs\eqbs}% % define \\ to be \\
+ \let\jslit\string
+% \end{macrocode}
+% \changes{v2.0n}{2014/05/20}{Remake the definition of \cs{\char`\{} and \cs{\char`\}}}
+% In an attempt to avoid the use of \verb~\jslit\{~ and \verb~\jslit\}~, we remake
+% the definition of \verb~\{} and \verb~\}~.
+% \begin{macrocode}
+ \let\{\dl@lBrace\let\}\dl@rBrace
+% \end{macrocode}
+% \changes{v2.1}{2015/07/12}{\cs{let} \cs{u} to \cs{@empty}.}
+% \cs{let} \cs{u} to \cs{@empty}.
+% \begin{macrocode}
+ \let\u\@empty
+ \def\({\eqbs(}\def\){\eqbs)}%
+ \makespecialJS % make \r=\jsR and \t=\jsT
+}
+% \end{macrocode}
+% \subsection{Open Document Actions}\label{opendocactions}
+% Early in the process of opening a document, the `\texttt{/OpenAction}' event occurs, where
+% various action-types may be executed. These actions occur before the document JavaScripts
+% are read and before any pages are opened. We give support for this event, originally part
+% of the \textsf{aeb\_pro} package.
+%\changes{v2.1}{2015/06/15}{Moved definition of \cs{addToDocOpen} from
+% \textsf{aeb\_pro} to \textsf{insdljs}, added support for \texttt{pdftex} and \texttt{xetex}
+% options.}
+% \paragraph*{Page views}
+% The view can be set when the page key is used. Possible values are
+% \texttt{fitpage}, \texttt{actualsize}, \texttt{fitwidth},
+% \texttt{fitvisible}, and \texttt{inheritzoom}. These terms correspond
+% to Acrobat's UI. When jumping to a destination, the view is set by the
+% destination code.
+% \begin{macrocode}
+\def\dl@fitpage{/Fit}
+\def\dl@actualsize{/XYZ null null 1.0} %{/XYZ -32768 -32768 1.0}
+\def\dl@fitwidth{/FitH null} %{/FitH -32768}
+\def\dl@fitheight{/FitV null} %{/FitV -32768}
+\def\dl@fitvisible{/FitBH null} %{/FitBH -32768}
+\def\dl@inheritzoom{/XYZ 0 0 0}
+\def\dl@mag#1{/XYZ null null #1}
+\edef\dl@Page#1{\ifcase\dljs@drivernum
+ {Page#1}\or\noexpand\pdfpageref#1\space\space 0 R\or
+ @page#1\fi}
+\def\dl@preProcDefns{\let\Page\dl@Page\let\mag\dl@mag
+ \let\fitpage\dl@fitpage\let\actualsize\dl@actualsize
+ \let\fitwidth\dl@fitwidth\let\fitheight\dl@fitheight
+ \let\fitvisible\dl@fitvisible\let\inheritzoom\dl@inheritzoom
+}
+\let\aeb@additionalOpenAction\@empty
+\let\aeb@addActionCode\@empty
+\let\addActionObj\@empty
+\let\aebpopentoks\@empty
+\let\aebpFA\dl@NO
+\def\aebp@rightDelimiters{}
+% \end{macrocode}
+% The argument of \DescribeMacro\addToDocOpen\cmd{\addToDocOpen} is an action-type, usually
+% \textbf{JavaScript} or a \textbf{GoTo}. The command is accumulative, it can be invoked several types
+% with different action-types. Must be executed in the preamble or it has no effect.
+% It populates the value of the key \textbf{/OpenAction} in the \textbf{Catalog} of the
+% PDF file.
+%\begin{verbatim}
+% \addToDocOpen{\JS{console.println("Open the doc!");}}
+% \addToDocOpen{/S/GoTo/D[\Page{2}\fitpage]}
+%\end{verbatim}
+% \begin{macrocode}
+\newcommand{\addToDocOpen}[1]{%
+ \ifx\aebpFA\dl@NO
+ \g@addto@macro\aebpopentoks{#1}%
+ \def\aeb@additionalOpenAction{/Next {pubAddToDocOpen}}%
+\ifpdf
+ \def\aeb@addActionCode{\immediate\pdfobj{<<
+ \aebpopentoks\aebp@rightDelimiters >>}%
+ \edef\addActionObj{\the\pdflastobj\space 0 R}}%
+\else\ifxetex
+ \def\aeb@addActionCode{\immediate
+ \@pdfm@mark{obj @objAddActionObj
+ << \aebpopentoks\aebp@rightDelimiters >> }}%
+ \def\addActionObj{@objAddActionObj}%
+\else % postscript
+ \def\aeb@addActionCode{\literalps@out{%
+ \AEB@psMrk/_objdef {pubAddToDocOpen}
+ /type/dict /OBJ pdfmark^^J%
+ \AEB@psMrk{pubAddToDocOpen} <<
+ \aebpopentoks\aebp@rightDelimiters >> /PUT pdfmark}}%
+ \def\addActionObj{{pubAddToDocOpen}}%
+\fi\fi
+ \global\let\aebpFA\dl@YES
+ \let\@pdfstartview\@empty
+ \else
+ \edef\aebp@dljstmp{\aebp@rightDelimiters}%
+ \xdef\aebp@rightDelimiters{\aebp@dljstmp >> }%
+ \g@addto@macro\aebpopentoks{/Next << #1 }%
+ \fi
+}
+\def\dljs@OpenActions{/OpenAction \addActionObj}
+\def\dljs@setOpenActions{\bgroup\makeJSspecials\dl@preProcDefns
+ \aeb@addActionCode
+ \ifpdf\pdfcatalog{\dljs@OpenActions}\else
+ \ifxetex\immediate
+ \@pdfm@mark{put @catalog <<\dljs@OpenActions>>}\else
+ \literalps@out{\AEB@psMrk
+ {Catalog} <<\dljs@OpenActions>> /PUT pdfmark}\fi\fi\egroup}
+% \end{macrocode}
+% If \textsf{aeb\_pro} is not loaded, we set the open actions. If \textsf{aeb\_pro}
+% is loaded, we do nothing for \textsf{aeb\_pro} has its own contributions to the
+% PDF \textbf{Catalog}.
+% \changes{v2.3d}{2017/01/08}{Use \cs{aebpFA} to detect open actions}
+% \begin{macrocode}
+\@ifpackageloaded{aeb_pro}{}
+ {\AtBeginDocument{\ifx\aebpFA\dl@YES\expandafter
+ \dljs@setOpenActions\fi}}
+% \end{macrocode}
+%
+% \subsection{Open Page Actions}\label{openaction}
+%
+% In order to get automatic insertion of DLJS using Distiller~5.0 or greater, it is necessary
+% to use a ``Page Open Action'' for page 1 of the document. This section contains some commands
+% for defining an open page action. Originally, these macros were defined only for Distiller
+% users (\textsf{dvips} and \textsf{dvipsone} users), later, I extended their use to
+% \textsf{pdftex} and \textsf{dvipdfm}.
+%
+%\subsubsection{\texorpdfstring{\cs{OpenAction}}{\textbackslash{OpenAction}}}
+%
+% Here are the macros that actually place the open page action into the PDF document. One for
+% the \textsf{Distiller}, one for \textsf{pdftex}, and one for \textsf{dvipdfm}.
+% \begin{macrocode}
+\let\@CloseAction\@empty
+\def\@OAction@pdfmark{\literalps@out{%
+ \AEB@psMrk{ThisPage} << /AA << /O << \theFirstAction\space
+ \opentoks\@rightDelimiters >> \@CloseAction >> >> /PUT pdfmark}}
+\def\@POAction@pdfmark{\literalps@out{%
+ \AEB@psMrk{ThisPage} << /AA << \@thisOpenAction
+ \@thisCloseAction >> >> /PUT pdfmark}%
+}
+\def\@OAction@pdftex{%
+ \ifx\isOpenAction\dl@YES
+ \xdef\pdftexOAction{/AA << /O << \theFirstAction\space
+ \opentoks\@rightDelimiters >> \@CloseAction >>}%
+ \AtNextShipout{\pdfpageattr=\expandafter{\pdftexOAction}}%
+ \fi
+}
+\def\@POAction@pdftex{%
+ \xdef\thisPageActionpdftex{/AA << \@thisOpenAction
+ \@thisCloseAction >>}%
+ \AtNextShipout{\pdfpageattr=\expandafter{\thisPageActionpdftex}}%
+}
+% \end{macrocode}
+% For \textsf{dvipdfm}
+% \begin{macrocode}
+\def\@OAction@dvipdfm{\ifx\isOpenAction\dl@YES
+ \@pdfm@mark{put @thispage << /AA << /O << \theFirstAction\space
+ \opentoks\@rightDelimiters >> \@CloseAction >> >>}\fi
+}
+\def\@POAction@dvipdfm{%
+ \@pdfm@mark{put @thispage << /AA << \@thisOpenAction
+ \@thisCloseAction >> >>}%
+}
+% \end{macrocode}
+% Now we choose the one appropriate to the user's driver option.
+% \begin{macrocode}
+\ifcase\dljs@drivernum
+ \let\@OAction\@OAction@pdfmark
+ \let\@POAction\@POAction@pdfmark
+ \gdef\theFirstAction{/S/JavaScript/JS (\the\importfdftoks)}
+ \let\isOpenAction\dl@YES
+\or
+ \let\@OAction\@OAction@pdftex
+ \let\@POAction\@POAction@pdftex
+ \AtBeginDocument{\@OAction@pdftex}
+\or
+ \let\@OAction\@OAction@dvipdfm
+ \let\@POAction\@POAction@dvipdfm
+ \AtBeginDocument{\@OAction@dvipdfm}
+\fi
+% \end{macrocode}
+% \begin{macro}{\OpenAction}
+% In order for the DLJS to be inserted, \texttt{insdljs} places an open page action
+% on the first page. If the document author wants his/her own open page action, inserting
+% it with the pdfmark operator may lead to unpredictable results. For the uses of the
+% Distiller (dvipsone and dvips users of the distiller), if additional open page action
+% is needed on the first page, you can insert this action using the \cmd{\nextOAction} command.
+%
+%\medskip\noindent Usage
+%\begin{verbatim}
+% \OpenAction{\JS{app.beep(-1); app.alert("Welcome to my Page!",3);}}
+%\end{verbatim}
+% The macro takes two parameters, the \cmd{\Next} followed by the desired action, in this
+% case it is a JavaScript action.
+%
+% From the code below, you can see that \cmd{\nextOAction} ends calling itself. If the next token
+% is a \cmd{\Next}, additional code is entered into the open page action. Thus, for example, the
+% following code is effectively the same as the above example, but the individual lines are
+% listed separately in the GUI action dialog of Acrobat.
+%\begin{verbatim}
+% \OpenAction{\JS{app.beep(-1);}}
+% \Next{\JS{app.alert("Welcome to my Page!",3);}}
+%\end{verbatim}
+% In the above example, several open page actions are ``chained'' together.
+%
+% You are not restricted to JavaScript actions, for example, you can perform a \texttt{Named}
+% action:
+%\begin{verbatim}
+% \OpenAction{/S/Named/N/Open}
+%\end{verbatim}
+% There is a |\Named| command that expands to |/S /Named /N#1|, so the above
+% example can be written
+%\begin{verbatim}
+% \OpenAction{\Named{Open}}
+%\end{verbatim}
+%\cs{opentoks} accumulates the ``action''.
+% \begin{macrocode}
+%\newtoks\opentoks \opentoks={}
+\def\opentoks{}
+% \end{macrocode}
+% The open action is really not meant for anything too fancy, such as searching using regular
+% expressions. Of the special characters, we include only \cs{r} and \cs{t} for formatting
+% purposes. If you want to use a regular expression in the open page action (not likely),
+% put it at the document level as a JavaScript function, and call that function from the
+% open page action.
+% \begin{macrocode}
+\def\makespecialJS{%
+ \let\r\jsR\let\t\jsT\let\n\jsN}
+\def\@rightDelimiters{}
+% \end{macrocode}
+% If the next token is \cs{Next} then we gobble it up, and begin \cs{@OpenAction}
+% otherwise we begin \cs{@OpenAction}. This allows the ``chaining'' as illustrated above.
+% \begin{macrocode}
+\def\OpenAction{\@ifnextchar\Next
+ {\expandafter\@OpenAction\@gobble}{\@OpenAction}}
+% \end{macrocode}
+% \cs{@OpenAction}: This is the macro that actually does the work. We differentiate between whether the
+% current argument \texttt{\#1} is the first of all open actions, or not. If the former,
+% we define it as \cs{theFirstAction}, and reset \cs{isOpenAction}, which keeps track of
+% whether there has been a \textit{prior} open action defined. If the latter, we place it in
+% the \cs{opentoks} token register.
+% \begin{macrocode}
+\def\@OpenAction#1{%
+ \ifx\isOpenAction\dl@NO
+ {\makespecialJS\xdef\theFirstAction{#1}}%
+ \global\let\isOpenAction\dl@YES
+ \else
+ \edef\dljstmp{\@rightDelimiters}%
+ \xdef\@rightDelimiters{\dljstmp >> }%
+ {\makespecialJS\xdef\dljstmp{\opentoks /Next << #1 }}%
+ \xdef\opentoks{\dljstmp}%
+ \fi
+ \@nextOpenAction
+}
+% \end{macrocode}
+% As its last act, \cs{@OpenAction} calls \cs{@nextOpenAction}, which is nearly identical to
+% \cs{OpenAction}, except if there is no \cs{Next} token, the macro terminates.
+% \begin{macrocode}
+\def\@nextOpenAction{\@ifnextchar\Next{\expandafter
+ \@OpenAction\@gobble}{}}
+% \end{macrocode}
+% \end{macro}
+% Here is a last example that uses the \texttt{insDLJS} environment and the \cs{OpenAction} command. This code
+% will cause the following action: Ten seconds after the document is opened, an annoying
+% message is placed on the screen. The annoying message appears only \texttt{once}, otherwise,
+% it would really be annoying. Reader (Acrobat)~5.0 is required for this code.
+%\begin{verbatim}
+%\begin{insDLJS}[DoIt]{doit}{DoIt}
+%var timeout;
+%var didIt = false;
+%var myWelcome="Welcome to your PDF Page!\r\r You can remove this annoying"
+% +" message by sending \u00A3100 to my Swiss bank account!"
+%function startToDoIt()
+%{
+% if(!didIt) timeout = app.setInterval("DoIt();", 10000);
+%}
+%function DoIt()
+%{
+% app.beep(-1);
+% app.alert(myWelcome,1);
+% app.clearInterval(timeout);
+% didIt = true;
+%}
+%\end{insDLJS}
+%\OpenAction{/S /JavaScript /JS(startToDoIt();)}
+%\end{verbatim}
+% See the ``Acrobat JavaScript Object Specification'' for the definitions of some
+% of these JavaScript methods.
+%
+%\subsubsection{\texorpdfstring{\cs{thisPageAction}}{\textbackslash{thisPageAction}}}
+% \DescribeMacro{\thisPageAction} places page actions on the current page.
+% The first argument is on open page action, the second one is a closed page action.
+% \begin{macrocode}
+\def\protectJSCtrls{\def\r{\string\r\string\n}%
+ \def\t{\string\t}\def\n{\string\n}}
+\def\dljs@tstlp{\@ifnextchar\bgroup
+ {\let\dljs@multi\dl@YES\dljs@tstlpi}%
+ {\let\dljs@multi\dl@NO\dljs@tstlpi}}
+\def\dljs@tstlpi#1\@nil{}%
+% #1=arg, #2=O|C, #3=cmd
+\def\dljs@bldScript#1#2#3{{%
+ \dljs@tstlp#1\@nil
+ \ifx\dljs@multi\dl@NO{\protectJSCtrls\xdef#3{/#2<<#1>>}}\else
+ \toks0={}\let\dljs@rAngles\@empty\count0=0
+ \@tfor\dljs@arg:=#1\do{%
+ \ifnum\count0=0
+ \toks0=\expandafter{\dljs@arg}\else
+ \toks2=\expandafter{\dljs@arg}%
+ \edef\holdtokstmp{\the\toks0
+ /Next<<\the\toks2 }%
+ \edef\dljs@rAngles{\dljs@rAngles\space>>}%
+ \toks0=\expandafter{\holdtokstmp}%
+ \fi
+ \advance\count0by1
+ }%
+ {\protectJSCtrls\xdef#3{/#2<<\the\toks0 \dljs@rAngles>>}%
+ \xdef#3{#3}}%
+ \fi
+}}
+\newcommand{\thisPageAction}[2]{%
+ \let\@CloseAction\@empty
+ \let\@thisOpenAction\@empty
+ \let\@thisCloseAction\@empty
+ \def\dljs@argi{#1}\def\dljs@argii{#2}%
+% \end{macrocode}
+% On the first page, \cs{OpenAction} is used to process the open action
+% \begin{macrocode}
+ \ifnum\value{page}=1\relax
+ \ifx\dljs@argii\@empty\else
+ \dljs@bldScript{#2}{C}{\@CloseAction}\fi
+ \ifx\dljs@argi\@empty\else\dljs@tstlp#1\@nil
+ \ifx\dljs@multi\dl@NO\OpenAction{#1}\else
+ \@tfor\dljs@arg:=#1\do{\expandafter
+ \OpenAction\expandafter{\dljs@arg}%
+ }\fi
+ \fi
+ \else
+% \end{macrocode}
+% If this is not the first page, we just populate the \texttt{/O} dictionary
+% \begin{macrocode}
+ \ifx\dljs@argi\@empty\else
+ \dljs@bldScript{#1}{O}{\@thisOpenAction}\fi
+ \ifx\dljs@argii\@empty\else
+ \dljs@bldScript{#2}{C}{\@thisCloseAction}\fi
+ \@POAction
+ \fi
+}
+% \end{macrocode}
+% \subsection{The \texttt{insDLJS} Environments}
+%
+% \begin{macro}{insDLJS}\hypertarget{insDLJS}{}
+% \begin{macro}{insDLJS*}
+% This is the main environment defined by this package. These environments
+% first set some global variables, then set the program flow to driver-dependent
+% environments. There are two forms of this environment, the \texttt{insDLJS} and the
+% \texttt{insDLJS*}.
+%
+% The \texttt{insDLJS} is the simplest of the two environments. Any material
+% within the environment, eventually ends up in the DLJS section of the
+% PDF document
+%
+% The environment takes the \texttt{<base\_name>} and writes the
+% file \texttt{<base\_name>.djs}. This file contains a verbatim
+% listing of the JS within the environment, plus some changing of
+% catcodes. This file is then input back into the document at
+% \cmd{\AtBeginDocument} with the necessary code for
+% \textsf{pdftex} and \textsf{dvipdfm} properly place the JS.
+%
+% The case of \textsf{dvipsone} and \textsf{dvips} is a little different. A
+% \texttt{<base\_name>.djs} is written and input back, and a second file
+% \texttt{<base\_name>.fdf} is written. This second file is later input
+% into the PDF document after distillation.
+%
+% The syntax of usage for this environment, which takes three
+% arguments, is given next.
+%\begin{verbatim}
+% \begin{insDLJS}[<function>]{<base_name>}{<script_name>}
+% <JavaScript functions or exposed code>
+% ...
+% ...
+% \end{insDLJS}
+%\end{verbatim}
+% where,
+% \begin{description}
+% \item[\texttt{\#1:}] This optional parameter, \texttt{<function>},
+% is \emph{required} for the \texttt{dvipsone} and \texttt{dvips}
+% options; otherwise it is ignored. Its value must be the name of
+% one of the functions defined in the environment. This is used to
+% detect whether the DLJS has already be loaded by Acrobat.
+% \item[\texttt{\#2}:] This parameter, \texttt{<base\_name>}, is an
+% alphabetic word with no spaces and limited to eight characters. It
+% is used to build the names of auxiliary files and to build the
+% names of macros used by the environment.
+% \item[\texttt{\#3}:] The \texttt{<script\_name>} of your JavaScript.
+% This title will appear in the Documentlevel JavaScript dialog of
+% Acrobat.
+% \end{description}
+% Within the insDLJS environment, there are two types of comment characters:
+% (1) a \TeX{} comment (|%|) and (2) a JavaScript comment. The JavaScript
+% comments are `\texttt{//}', a line comment, and `\texttt{/*...*/}' for more
+% extensive commenting. These comments will survive and be placed into the
+% PDF file. In JavaScript the `|%|' is used as well, use |\%| when you want to use
+% the percent character in a JavaScript statement, for example
+% |app.alert("\%.2f", 3.14159);|, this statement will appear within your JavaScript
+% code as |app.alert("%.2f", 3.14159);|.
+% \changes{v2.2c}{2015/11/13}{Turned \cs{Hy@unicodefalse} so unicode is not written
+% in the name of the script.}
+% \begin{macrocode}
+\let\insdljsloadVar\@empty
+\newenvironment{insDLJS}[3][]
+{%
+ \gdef\detectdljs{#1}\gdef\dljsBase{#2}%
+ \ifxetex{\def\1{\string\1}\def\2{\string2}%
+ \def\3{\string\3}\xdef\dljsName{#3}}\else
+ \Hy@unicodefalse\pdfstringdef{\dljsName}{#3}\fi
+% \end{macrocode}
+% If the optional argument is not passed,
+% we generate one for the user.
+%\changes{v2.0k}{2012/06/21}{If the optional argument is not passed,
+% we generate one for the user.}
+% \begin{macrocode}
+\ifx\detectdljs\@empty
+ \stepcounter{dljs@cnt}%
+ \xdef\detectdljs{_bInsdljsload\arabic{dljs@cnt}}%
+ \edef\insdljsloadVar{var \detectdljs=true;}%
+ \addtocounter{dljs@cnt}{-1}%
+\fi
+ \global\let\multisegments\dl@NO\setcounter{dljssegs}{2}%
+ \global\dljsobjtoks={}%
+ \expandafter\ifx\csname dljs\dljsBase\endcsname\relax
+ \else\@insjserrDuplicate\fi
+ \ifcase\dljs@drivernum
+ \let\insert@DLJS=\insert@DLJS@pdfmark
+ \let\endinsDLJS=\endinsert@DLJS@pdfmark
+ \let\newsegment=\newsegment@pdfmark
+ \let\endnewsegment=\endnewsegment@pdfmark
+ \or
+ \let\insert@DLJS=\insert@DLJS@pdftex
+ \let\endinsDLJS=\endinsert@DLJS@pdftex
+ \let\newsegment=\newsegment@pdftex
+ \let\endnewsegment=\endnewsegment@pdftex
+ \or
+ \let\insert@DLJS=\insert@DLJS@dvipdfm
+ \let\endinsDLJS=\endinsert@DLJS@dvipdfm
+ \let\newsegment=\newsegment@dvipdfm
+ \let\endnewsegment=\endnewsegment@dvipdfm
+ \fi
+ \insert@DLJS
+}{}
+% \end{macrocode}
+%
+% The \texttt{insDLJS*} environment can be used to better organize,
+% edit and debug your JavaScript. If you have the full Acrobat
+% product, you can open the DLJS edit dialog. There you will see a
+% listing of all DLJS contained in the document. When you double
+% click on one of the \textsl{script names}, you enter the edit
+% window, where you can edit all JavaScript contained under that
+% name. Each \texttt{insDLJS} environment creates a new listing
+% within this DLJS dialog; and, each environment creates a
+% `\texttt{.djs}' file and possibly a \texttt{.fdf}' file. Each
+% \texttt{insDLJS*} environment also creates a `\texttt{.djs}' file
+% and possibly a `\texttt{.fdf}' file too, but within the
+% \texttt{insDLJS*} environment you can create JavaScript under
+% different \textsl{script names}.
+%
+% The syntax is
+%\begin{verbatim}
+% \begin{insDLJS*}[<function>]{<base_name>}
+% \begin{newsegment}{<script_name>}
+% <JavaScript functions or exposed code>
+% \end{newsegment}
+% \begin{newsegment}{<script_name>}
+% <JavaScript functions or exposed code>
+% \end{newsegment}
+% ...
+% ...
+% <JavaScript functions or exposed code>
+% \end{newsegment}
+% \begin{newsegment}{<name_name>}
+% <JavaScript functions or exposed code>
+% \end{newsegment}
+% \end{insDLJS*}
+%\end{verbatim}
+% where,
+% \begin{description}
+% \item[\texttt{\#1:}] This optional parameter, \texttt{<function>},
+% is \emph{required} for the \texttt{dvipsone} and \texttt{dvips}
+% options; otherwise it is ignored. Its value must be the name of
+% one of the functions defined in the environment. This is used to
+% detect whether the DLJS has already be loaded by Acrobat.
+% \item[\texttt{\#2}:] This parameter, \texttt{<base\_name>}, is an
+% alphabetic word with no spaces and limited to eight characters. It
+% is used to build the names of auxiliary files and to build the
+% names of macros used by the environment.
+% \item[\texttt{\#3}:] The \texttt{<script\_name>} of your JavaScript.
+% This title will appear in the Document level JavaScript dialog of
+% Acrobat.
+% \end{description}
+% \begin{macrocode}
+\newenvironment{insDLJS*}[2][]
+{%
+ \gdef\detectdljs{#1}\gdef\dljsBase{#2}%
+% \end{macrocode}
+% If the optional argument is not passed,
+% we generate one for the user.
+%\changes{v2.0k}{2012/06/21}{If the optional argument is not passed,
+% we generate one for the user.}
+% \begin{macrocode}
+\ifx\detectdljs\@empty
+ \stepcounter{dljs@cnt}%
+ \xdef\detectdljs{_bInsdljsload\arabic{dljs@cnt}}%
+ \edef\insdljsloadVar{var \detectdljs=true;}%
+ \addtocounter{dljs@cnt}{-1}%
+\fi
+ \global\let\multisegments\dl@YES\setcounter{dljssegs}{2}%
+ \global\dljsobjtoks={}%
+ \expandafter\ifx\csname dljs\dljsBase\endcsname\relax
+ \else\@insjserrDuplicate\fi
+ \ifcase\dljs@drivernum
+ \let\insert@DLJS=\insert@DLJS@pdfmark
+ \expandafter
+ \let\csname endinsDLJS*\endcsname\endinsert@DLJS@pdfmark
+ \let\newsegment=\newsegment@pdfmark
+ \let\endnewsegment=\endnewsegment@pdfmark
+ \or
+ \let\insert@DLJS=\insert@DLJS@pdftex
+ \expandafter
+ \let\csname endinsDLJS*\endcsname\endinsert@DLJS@pdftex
+ \let\newsegment=\newsegment@pdftex
+ \let\endnewsegment=\endnewsegment@pdftex
+ \or
+ \let\insert@DLJS=\insert@DLJS@dvipdfm
+ \expandafter
+ \let\csname endinsDLJS*\endcsname\endinsert@DLJS@dvipdfm
+ \let\newsegment=\newsegment@dvipdfm
+ \let\endnewsegment=\endnewsegment@dvipdfm
+ \fi
+ \insert@DLJS
+}{}
+\def\@insjserrDuplicate{%
+ \typeout{^^J! insdljs Package error.}
+ \typeout{! insDLJS environment: On line number \the\inputlineno,}
+ \typeout{! the base name `\dljsBase' has already been chosen.}
+ \typeout{! A DLJS earlier defined has been overwritten!}
+ \typeout{! Choose another name for the first required argument}
+ \typeout{! of the insDLJS environment.^^J}
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+% \subsection{The \texttt{execJS} Environment}\label{execJS}
+% This environment works only for those document authors using Acrobat 5.0 or
+% Acrobat Approval. The \texttt{execJS} environment writes a verbatim \texttt{.djs} and
+% \texttt{.fdf} files using the same scheme as \texttt{insDLJS} environment.
+% The \texttt{.fdf} file is imported into the newly created PDF document and the JavaScript contained
+% within the environments are executed.
+%
+% In order for the JavaScript to be imported and executed, the \texttt{execJS} must be used. The
+% JavaScript is executed once, when the document is first opened in Acrobat.
+%
+% This feature is potentially useful for developmental purposes.
+% \begin{macrocode}
+\newif\ifisdljs \isdljsfalse
+\begingroup
+\catcode`\~=12 \catcode`\#=12
+\gdef\efdlspecials{\catcode`\~=12 \catcode`\#=12}
+\endgroup
+\def\ckivspace#1{\if\noexpand#1\space\else\expandafter#1\fi}
+% \end{macrocode}
+% \changes{v2.2b}{2015/08/03}{Added a hook \cs{DLspecialDefs} into the DJS file}
+% (2015/08/03) Added the \cs{DLspecialDefs} hook into the DJS file, used in
+% \textsf{aeb\_pro}.
+% \begin{macrocode}
+\let\DLspecialDefs\@empty
+\def\fdfAfterheader
+{%
+ \iwvo{\string\begingroup\string\efdlspecials}
+ \iwvo{\string\DLspecialDefs}
+ \iwvo{\string\isdljstrue}
+ \iwvo{\string\makeatletter}
+ \iwvo{\string\immediate\string\openout\string
+\js@verbatim@out=\string\js@Path\space\dljsBase.fdf}%
+ \iwvo{\string\begin{jsexpverbatimwrite}}
+ \iwvo{\string\firstFDFline}
+ \iwvo{1 0 obj}
+ \iwvo{<< /FDF << /JavaScript << /Doc 2 0 R /After 3 0 R >> >> >> }
+ \iwvo{endobj}
+ \iwvo{2 0 obj}
+% \end{macrocode}
+% When a non-Distiller workflow, insure execJSs are listed first.
+% \changes{v2.2h}{2016/06/09}{When a non-Distiller workflow, insure execJSs are listed first}
+% \begin{macrocode}
+\ifpdfmarkup
+ \iwvo{[ (ExecJS \dljsBase) (var _\dljsBase\space = true;) ] }\else
+ \iwvo{[ (00 ExecJS \dljsBase) (var _\dljsBase\space = true;) ] }\fi
+ \iwvo{endobj}
+ \iwvo{3 0 obj}
+ \iwvo{<<>>}
+ \iwvo{stream}
+}
+% \end{macrocode}
+% \begin{environment}{execJS}
+% The parameter \texttt{\#1} is the base name for this environment.
+% The base name will be used to create
+% a filename to save the \texttt{.fdf} file under.
+% \begin{macrocode}
+\newenvironment{execJS}[1]
+{%
+ \gdef\detectdljs{\string_#1}\gdef\dljsBase{#1}%
+ \global\dljsobjtoks={}%
+ \expandafter\gdef\csname dljs\dljsBase\endcsname{}%
+ \ifx\importdljs\dl@YES\ifx\execjs\dl@YES
+ \ifx\dl@gopro\dl@YES
+ \ifnum\dljs@drivernum=0\relax
+ \addImportAnFDF\importAnFDFTemplate
+ \else
+ \OpenAction{/S/JavaScript/JS (\importAnFDFTemplate)}%
+ \fi\fi
+ \fi\fi
+ \immediate\openout \js@verbatim@out \js@Path\dljsBase.djs
+ \fdfAfterheader
+ \js@verbatimwrite
+}{%
+ \fdfendstreamobj
+ \endjs@verbatimwrite
+ \fdftrailer
+ \closejs@verbatim@out
+ \expandafter\xdef\csname\dljsBase OBJ\endcsname{\the\dljsobjtoks}%
+ \edef\@dljstmp{\noexpand\AtBeginDocument{%
+ \noexpand\input{\js@Path\dljsBase.djs}}}\@dljstmp
+% \end{macrocode}
+%\changes{v2.2g}{2016/05/11}{Removed \string\cs{AtBeginDocument} code
+%from the \string\texttt{execJS} environment. This causes problems with
+%the order of \string\texttt{execJS} and \string\texttt{insDLJS}.}
+%(2016/05/11) Remove the following code, seens to cause problems with
+%the order of \texttt{execJS} and \texttt{insDLJS}.
+%\begin{verbatim}
+% \ifx\firstdljs\dl@YES
+% \AtBeginDocument{\importAnFDF}%
+% \global\let\firstdljs\dl@NO
+% \fi
+%\end{verbatim}
+% \begin{macrocode}
+}
+% \end{macrocode}
+% \end{environment}
+% \subsection{The \texttt{defineJS} Environment}\label{defineJS}
+% When we create a form field that has a JavaScript action attached, it would be nice
+% to be able to write verbatim JavaScript code into the action. Due to the limitations
+% of \TeX, this is not possible. The other possibility is to create an environment for
+% writing JavaScript. This section introduced a couple of environments, the
+% \texttt{defineJS} and \texttt{localJS} environments.
+% \begin{environment}{defineJS}
+% The \texttt{defineJS} environment takes two parameters, the first one optional.
+%\begin{description}
+%\item[\ttfamily\#1 = ] This optional parameter can be used to change catcodes
+% before the verbatim read begins.
+%\item[\ttfamily\#2 = ] The command to be defined.
+%\end{description}
+% The material within the environment is read verbatim and a new command by the name of \#2
+% is defined.
+% \begin{macrocode}
+\newtoks\JStoks
+\newenvironment{defineJS}[2][]
+{%
+ \expandafter\@ifundefined\expandafter{%
+ \expandafter\@gobble\string#2}{}{%
+ \PackageWarning{insdljs}{The command
+ \string#2 already defined}}%
+ \gdef\defineJSArg{#2}\JStoks={}%
+ \def\verbatim@processline
+ {%
+ \xdef\JS@temp{\the\JStoks\the\verbatim@line\defineJSjsR}%
+ \global\JStoks=\expandafter{\JS@temp}%
+ }%
+ \let\do\@makeother\dospecials\catcode`\^^M\active
+ #1%
+ \verbatim@start
+}{\gdef\eq@JStemp{\expandafter\edef\defineJSArg{\the\JStoks}}%
+ \aftergroup\eq@JStemp}
+% \end{macrocode}
+% Silent version of \texttt{defineJS}, can repeatedly be used to redefine the same
+% macro.
+% \begin{macrocode}
+\newenvironment{@defineJS}[2][]
+{%
+ \gdef\defineJSArg{#2}\JStoks={}%
+ \def\verbatim@processline
+ {%
+ \xdef\JS@temp{\the\JStoks\the\verbatim@line\defineJSjsR}%
+ \global\JStoks=\expandafter{\JS@temp}%
+ }%
+ \let\do\@makeother\dospecials\catcode`\^^M\active
+ #1%
+ \verbatim@start
+}{\gdef\eq@JStemp{\expandafter\edef\defineJSArg{\the\JStoks}}%
+ \aftergroup\eq@JStemp}
+% \end{macrocode}
+% \end{environment}
+% An author might want these definitions to be local in definition, so the
+% \texttt{localJS} environment is supplied.
+% \begin{environment}{localJS}
+% This environment does nothing more than to enclose the material
+% in \cs{begingroup} and \cs{endgroup}.
+% \begin{macrocode}
+\newenvironment{localJS}[1][]{}{\ifvmode\else\unskip\fi}
+% \end{macrocode}
+% \end{environment}
+%
+% \subsection{Set Document Actions}
+% We provide simple environments for writing document actions.
+% \begin{environment}{willClose}
+% Execute a script just before closing the document.
+% \begin{environment}{willSave}
+% Execute script just before a save.
+% \begin{environment}{didSave}
+% Execute a script just after a save
+% \begin{environment}{willPrint}
+% Execute a script just before a print job
+% \begin{environment}{didPrint}
+% Execute a script just after a print job
+% \begin{macrocode}
+\newenvironment{willClose}[1][]
+{\@defineJS[#1]{\will@Close}}
+{\end@defineJS}
+\let\will@Close\@empty
+\newenvironment{willSave}[1][]
+{\@defineJS[#1]{\will@Save}}
+{\end@defineJS}
+\let\will@Save\@empty
+\newenvironment{didSave}[1][]
+{\@defineJS[#1]{\did@Save}}
+{\end@defineJS}
+\let\did@Save\@empty
+\newenvironment{willPrint}[1][]
+{\@defineJS[#1]{\will@Print}}
+{\end@defineJS}
+\let\will@Print\@empty
+\newenvironment{didPrint}[1][]
+{\@defineJS[#1]{\did@Print}}
+{\end@defineJS}
+\let\did@Print\@empty
+\def\dljs@willDidActions{/AA <<
+ \ifx\test@will@Close\@empty\else/WC <<
+ \JS{\will@Close} >>\fi
+ \ifx\test@will@Save\@empty\else/WS <<
+ \JS{\will@Save} >>\fi
+ \ifx\test@did@Save\@empty\else/DS <<
+ \JS{\did@Save} >>\fi
+ \ifx\test@will@Print\@empty\else/WP <<
+ \JS{\will@Print} >>\fi
+ \ifx\test@did@Print\@empty\else/DP <<
+ \JS{\did@Print} >>\fi
+ >>
+}
+\newcommand\dljs@setDocActions{%
+ \edef\test@will@Close{\will@Close}%
+ \edef\test@will@Save{\will@Save}%
+ \edef\test@did@Save{\did@Save}%
+ \edef\test@will@Print{\will@Print}%
+ \edef\test@did@Print{\did@Print}%
+% \end{macrocode}
+% Driver dependent code to put any document actions into the additional actions
+% dictionary of the document catalog.
+% \begin{macrocode}
+ \ifpdf\pdfcatalog{\dljs@willDidActions}\else
+ \ifxetex\immediate
+ \@pdfm@mark{put @catalog <<\dljs@willDidActions>>}\else
+ \literalps@out{\AEB@psMrk
+ {Catalog} <<\dljs@willDidActions>> /PUT pdfmark}\fi\fi
+}
+\@ifpackageloaded{aeb_pro}{}
+ {\AtBeginDocument{\dljs@setDocActions}}
+% \end{macrocode}
+% \end{environment}
+% \end{environment}
+% \end{environment}
+% \end{environment}
+% \end{environment}
+%
+% \subsection{For \texttt{dvipsone}/\texttt{dvips}}
+% The method of automatic insertion of document level JavaScript is to
+% write an FDF file (Forms Data Format), then import this FDF into the
+% document using the JavaScript method \texttt{Doc.importAnFDF()}.
+%
+% We break the FDF file into three parts: the \cmd{\fdfheader} (the stuff prior
+% to the JavaScript code); the JavaScript code itself; and the
+% \cmd{\fdftrailer}, the stuff that follows the code.
+% \begin{macrocode}
+\begingroup
+\catcode`\%=12
+\gdef\firstFDFline{%FDF-1.2}
+\gdef\lastFDFline{%%EOF}
+\endgroup
+\def\fdfheader
+{%
+ \iwvo{\string\begingroup\string\efdlspecials}
+ \iwvo{\string\isdljstrue}
+ \iwvo{\string\makeatletter}
+ \iwvo{\string\immediate\string\openout\string
+ \js@verbatim@out=\string\js@Path\space\dljsBase.fdf}%
+ \iwvo{\string\begin{jsexpverbatimwrite}}
+ \iwvo{\string\firstFDFline}
+ \iwvo{1 0 obj}
+ \iwvo{<< /FDF << /JavaScript << /Doc 2 0 R >> >> >>}
+ \iwvo{endobj}
+ \iwvo{2 0 obj}
+ \iwvo{[ \string\csname\string\@gobble\space\dljsBase%
+ OBJ\string\endcsname]}
+ \iwvo{endobj}
+}
+\def\fdfbeginstreamobj
+{%
+ \iwvo{\thedljssegs\space 0 obj}
+ \iwvo{<<>>}
+ \iwvo{stream}
+% \end{macrocode}
+% If the user has not passed the optional
+% name, we generated one for him, now we insert it into the \texttt{stream}.
+%\changes{v2.0k}{2012/06/21}{If the user has not passed the optional
+% name, we generated one for him, now we insert it into the \texttt{stream}.}
+% \begin{macrocode}
+ \ifx\insdljsloadVar\@empty\else
+ \iwvo{\insdljsloadVar}
+ \global\let\insdljsloadVar\@empty
+ \fi
+}
+\def\fdfendstreamobj{%
+ \iwvo{endstream}
+ \iwvo{endobj}
+}
+ \def\fdftrailer{%
+ \iwvo{trailer}
+ \iwvo{<< /Root 1 0 R >>}
+ \iwvo{\string\lastFDFline}
+% \end{macrocode}
+% Here we write \texttt{*end{jsexpverbatimwrite}} as a signal for our modified verbatim write
+% code to stop.
+% \begin{macrocode}
+ \iwvo{*end{jsexpverbatimwrite}}
+ \iwvo{\string\endgroup}
+}
+% \end{macrocode}
+% There may be more than one use of the \texttt{insDLJS}
+% environment and we need to be able to import each of the resultant
+% FDF files. The \cmd{\importfdftoks} accumulates material to be
+% used after all chance for the user to insert JS code has been
+% exhausted.
+% \begin{macrocode}
+\newtoks\importfdftoks \importfdftoks={}
+\newtoks\dljsobjtoks \dljsobjtoks={}
+% \end{macrocode}
+% This is a template for detecting whether the DLJS has been imported into
+% the document.
+% \begin{macrocode}
+\def\importAnFDFTemplate{%
+if(typeof \detectdljs\space == "undefined")\jsR\jsT
+% \end{macrocode}
+% Beginning with Acrobat 8.1, the \texttt{Doc.importAnFDF} has additional security. We must call
+% it through a trusted function which is in the file aeb.js, which resides in the user JavaScript folder.
+%\changes{v2.0h}{2006/10/03}
+%{
+% Created aeb.js, which must be installed for users of distiller. The importAnFDF method is now called
+% through a trusted function.
+%}
+% \begin{macrocode}
+ ( app.viewerVersion > 8 ) ? %
+ aebTrustedFunctions( this, aebImportAnFDF, %
+ "\js@Path\dljsBase.fdf") : %
+ this.importAnFDF("\js@Path\dljsBase.fdf");\jsR
+}
+% \end{macrocode}
+% Add in another template into \cmd{\importfdftoks}.
+% \begin{macrocode}
+\def\addImportAnFDF#1{%
+ \ifx\importdljs\dl@YES
+% \let\jsR\relax\let\jsT\relax
+ \edef\importAnFDFtmp{\the\importfdftoks#1}%
+ \global\importfdftoks=\expandafter{\importAnFDFtmp}%
+ \fi
+}
+% \end{macrocode}
+% This is used by \texttt{insert@DLJS@pdfmark} and is placed
+% \cmd{\AtBeginDocument}.
+% \begin{macrocode}
+\def\importAnFDF{\ifx\importdljs\dl@YES\@OAction\fi}
+% \end{macrocode}
+% The \texttt{insert@DLJS@pdfmark} environment writes the \cmd{\dljsBase.djs} file
+% which is in turn input back in, and rewritten as \cmd{\dljsBase.fdf}. This is
+% necessary to give the user a chance to modify the JavaScript code in an
+% authorized way.
+% \begin{macrocode}
+\newenvironment{newsegment@pdfmark}[1]{%
+ \addtocounter{dljssegs}{1}%
+ \addtocounter{dljs@cnt}{1}%
+ \Hy@unicodefalse\pdfstringdef{\dljsName}{#1}%
+ \edef\@dljstmp{\the\dljsobjtoks(\dljsName)
+ \thedljssegs\space 0 R\space}
+ \global\dljsobjtoks=\expandafter{\@dljstmp}
+ \fdfbeginstreamobj
+ \js@verbatimwrite
+}{%
+ \fdfendstreamobj
+ \endjs@verbatimwrite
+}
+\def\insert@DLJS@pdfmark{%
+ \global\let\dljspresent\dl@YES
+ \expandafter\gdef\csname dljs\dljsBase\endcsname{}%
+ \ifx\importdljs\dl@YES\ifx\dl@gopro\dl@YES
+ \addImportAnFDF\importAnFDFTemplate
+ \fi\fi
+ \immediate\openout \js@verbatim@out \js@Path\dljsBase.djs
+ \fdfheader
+ \ifx\multisegments\dl@NO\expandafter
+ \newsegment\expandafter{\expandafter\dljsName\expandafter}\fi
+}
+\def\endinsert@DLJS@pdfmark{%
+ \ifx\importdljs\dl@YES
+ \ifx\multisegments\dl@NO\expandafter\endnewsegment\fi
+ \fdftrailer
+ \closejs@verbatim@out
+ \expandafter\xdef\csname\dljsBase%
+ OBJ\endcsname{\the\dljsobjtoks}%
+ \edef\@dljstmp{\noexpand\AtBeginDocument{%
+ \noexpand\input{\js@Path\dljsBase.djs}}}%
+ \@dljstmp
+ \ifx\firstdljs\dl@YES
+ \AtBeginDocument{\edef\@dljstmp{\importAnFDF}%
+ \@dljstmp}\global\let\firstdljs\dl@NO
+ \fi
+ \fi
+}
+% \end{macrocode}
+% \subsection{For \texttt{pdftex}/\texttt{dvipdfm}}
+% Again, we break the problem of creating DLJS into four parts: \cmd{\begindljs},
+% \cmd{\enddljs}, the code itself, driver dependent material, \cmd{\write@pdftex@obj}
+% and \cmd{\write@dvipdfm@obj}.
+%
+% The following is used by both \texttt{pdftex} and \texttt{dvipdfm}.
+% \begin{macrocode}
+\begingroup
+\catcode`\@=0 @catcode`@\=12
+@gdef@ccpdftex{@gdef@eqesc{\\}@gdef@eqesci{\}}
+@endgroup
+\def\begindljs
+{%
+ \iwvo{\string\begingroup\string\efdlspecials}
+ \iwvo{\string\isdljstrue}
+% \end{macrocode}
+%\changes{v2.2f}{2016/05/07}{Include \string\cs{makeletter} in verbatim write}
+% \begin{macrocode}
+ \iwvo{\string\makeatletter}
+ {\uccode`c=`\%\uppercase{%
+ \iwvo{\string\obeyspaces\string\obeylines
+ \string\let\string^\string^M=\string\jsR c}}}
+% \end{macrocode}
+% (2014/08/09) For pdftex and xetex, this global let messages up
+% the \texttt{Verbatim} environment. Not sure why this is global anyway
+%\begin{verbatim}
+% \iwvo{\string\obeyspaces\string\obeylines\string
+% \global\string\let\string^\string^M=\string\jsR c}}}
+%\end{verbatim}
+% \begin{macrocode}
+ {\escapechar=-1 \lccode`C=`\%\lowercase{%
+ \iwvo{\string\\catcode`\string\\"=12C}}}
+}
+\def\beginseg
+{%
+ {\lccode`P=`\{\lccode`C=`\%\lowercase{%
+ \iwvo{\string\gdef\string\dljs\dljsBase\roman{dljssegs}PC}}}%
+}
+% \end{macrocode}
+% With \cs{enddsljs}, we now finish the macro definition with a closing right brace, followed by a
+% comment, `\texttt\%, and an end of group.
+% \begin{macrocode}
+\def\endseg
+{%
+ {\uccode`c=`\%\uccode`p=`\}\uppercase{\iwvo{pc}}}%
+}
+\def\enddljs
+{%
+ \iwvo{\string\endgroup}%
+}
+% \end{macrocode}
+%\changes{v2.0j}{2011/06/27}{made some changes as suggested by Christian Feuersaenger, who reported some
+% problem clashes between \textsf{babel} (spanish) and \textsf{insdljs}.}
+% \begin{macrocode}
+\def\@roman#1{\romannumeral#1}
+\def\write@objs
+{%
+ \iwvo{\begingroup}
+ \iwvo{\string\catcode`\string\<=12 }
+ \iwvo{\string\catcode`\string\>=12 }
+ {\lccode`C=`\%\lowercase{\iwvo{\string\ccpdftex C}}}
+ {\lccode`C=`\%\lowercase{\iwvo{%
+ \string\input{dljscc.def}C\the\dljsobjtoks}}}
+ \iwvo{\endgroup}
+}
+% \end{macrocode}
+% \subsubsection{\texttt{pdftex} Specific Code}
+% \begin{macrocode}
+\newenvironment{newsegment@pdftex}[1]{%
+ \addtocounter{dljssegs}{1}%
+ \addtocounter{dljs@cnt}{1}%
+ \edef\tmp{^^J\string\immediate\string\pdfobj{ << /S/JavaScript/JS%
+ (\string\dljs\dljsBase\roman{dljssegs}) >> }}%
+ \edef\@dljstmp{\the\dljsobjtoks\tmp}%
+ \global\dljsobjtoks=\expandafter{\@dljstmp}%
+ \edef\tmp{^^J\string\xdef\string\obj\dljsBase\roman{dljssegs}%
+ {\string\the\string\pdflastobj\string\space 0 R}}%
+ \edef\@dljstmp{\the\dljsobjtoks\tmp}%
+ \global\dljsobjtoks=\expandafter{\@dljstmp}%
+ \edef\curr@Cnt{\ifnum\arabic{dljs@cnt}<10 0\fi\arabic{dljs@cnt}}%
+ \Hy@unicodefalse\pdfstringdef{\dljsName}{#1}%
+ \edef\dljspdftextmp
+ {\the\importfdftoks (\curr@Cnt\space\dljsName)
+ \noexpand\csname obj\dljsBase\roman{dljssegs}%
+ \noexpand\endcsname\space}%
+ \global\importfdftoks=\expandafter{\dljspdftextmp}%
+ \beginseg
+ \js@verbatimwrite
+}{%
+ \endjs@verbatimwrite
+ \endseg
+}
+% \end{macrocode}
+% The main branch of the \texttt{insDLJS} for \texttt{pdftex}. This
+% environment writes to the file \cmd{\dljsBase.djs} all the necessary code, then
+% is input back into the file using \cmd{\AtBeginDocument}.
+% \begin{macrocode}
+\newenvironment{insert@DLJS@pdftex}{%
+ \expandafter\gdef\csname dljs\dljsBase\endcsname{}%
+ \immediate\openout \js@verbatim@out \js@Path\dljsBase.djs
+ \begindljs
+ \ifx\multisegments\dl@NO\expandafter
+ \newsegment\expandafter{\expandafter\dljsName\expandafter}\fi
+}{%
+ \ifx\multisegments\dl@NO\expandafter\endnewsegment\fi
+ \enddljs
+ \write@objs
+ \endjs@verbatimwrite
+ \closejs@verbatim@out
+ \edef\@dljstmp{\noexpand\AtBeginDocument{%
+ \noexpand\input{\js@Path\dljsBase.djs}}}%
+ \@dljstmp
+ \ifx\importdljs\dl@YES
+ \ifx\firstdljs\dl@YES
+ \AtEndDocument{\edef\@dljstmp{\setDLJSRef@pdftex}\@dljstmp}
+ \global\let\firstdljs\dl@NO
+ \fi
+ \fi
+}
+% \end{macrocode}
+% This code places the \texttt{/JavaScript} key-value in the \texttt{/Names} dictionary
+% of the PDF document. This code is inserted into the document in \texttt{insert@DLJS@pdftex}
+% using \cmd{\AtEndDocument}.
+% \begin{macrocode}
+\def\setDLJSRef@pdftex
+{%
+ \noexpand\immediate\noexpand\pdfobj {%
+ << /Names [\the\importfdftoks] >> }%
+ \edef\noexpand\objNames{\noexpand\the\noexpand\pdflastobj\space 0 R}%
+ \pdfnames {/JavaScript \noexpand\objNames}%
+}
+% \end{macrocode}
+% \subsubsection{\texttt{dvipdfm} Specific Code}
+% Begin by writing driver-specific code to \cmd{\dljsBase.djs}.
+% \begin{macrocode}
+\newenvironment{newsegment@dvipdfm}[1]
+{%
+ \addtocounter{dljssegs}{1}%
+ \addtocounter{dljs@cnt}{1}%
+ \edef\tmp{^^J\string\immediate\string
+ \csname\space @pdfm@mark\string\endcsname
+ {obj @obj\dljsBase\roman{dljssegs}\space << /S/JavaScript%
+ /JS(\string\dljs\dljsBase\roman{dljssegs}) >> }}%
+ \edef\@dljstmp{\the\dljsobjtoks\space\tmp}%
+ \global\dljsobjtoks=\expandafter{\@dljstmp}%
+ \edef\curr@Cnt{\ifnum\arabic{dljs@cnt}<10 0\fi\arabic{dljs@cnt}}%
+ {\def\1{\string\1}\def\2{\string2}%
+ \def\3{\string\3}\xdef\dljsName{#1}}%
+ \edef\dljspdftextmp
+ {\the\importfdftoks (\curr@Cnt\space \dljsName) %
+ @obj\dljsBase\roman{dljssegs}\space}%
+ \global\importfdftoks=\expandafter{\dljspdftextmp}%
+ \beginseg
+ \js@verbatimwrite
+}{%
+ \endjs@verbatimwrite
+ \endseg
+}
+% \end{macrocode}
+% This code places the \texttt{/JavaScript} key-value in the \texttt{/Names} dictionary
+% of the PDF document. This code is inserted into the document in \texttt{insert@DLJS@dvipdfm}
+% using \cmd{\AtEndDocument}.
+% \begin{macrocode}
+\def\setDLJSRef@dvipdfm
+{%
+ \immediate\@pdfm@mark{obj @objnames %
+ << /Names [\the\importfdftoks] >> }%
+ \@pdfm@mark{put @names %
+ << /JavaScript @objnames >> }%
+}
+% \end{macrocode}
+% The main branch of the \texttt{insDLJS} for \texttt{dvipdfm}. This
+% environment writes to the file \cmd{dljsBase.djs} all the necessary code, then
+% is input back into the file using \cmd{\AtBeginDocument}.
+% \begin{macrocode}
+\newenvironment{insert@DLJS@dvipdfm}
+{%
+ \expandafter\gdef\csname dljs\dljsBase\endcsname{}%
+ \immediate\openout \js@verbatim@out \js@Path\dljsBase.djs
+ \begindljs
+ \ifx\multisegments\dl@NO\expandafter\newsegment\expandafter{%
+ \expandafter\dljsName\expandafter}\fi
+}{%
+ \ifx\multisegments\dl@NO\expandafter\endnewsegment\fi
+ \enddljs
+ \write@objs
+ \endjs@verbatimwrite
+ \closejs@verbatim@out
+ \edef\@dljstmp{\noexpand\AtBeginDocument{%
+ \noexpand\input{\js@Path\dljsBase.djs}}}%
+ \@dljstmp
+ \ifx\importdljs\dl@YES
+ \ifx\firstdljs\dl@YES
+% \end{macrocode}
+% 2012/06/09 Changed positioning of \cmd{\setDLJSRef@dvipdfm}.
+% \begin{macrocode}
+ \AtBeginDocument{\setDLJSRef@dvipdfm}%
+% \AtEndDocument{\setDLJSRef@dvipdfm}
+ \global\let\firstdljs\dl@NO
+ \fi
+ \fi
+}
+\catcode`\"=\dl@dquoteCat
+%</package>
+% \end{macrocode}
+% \begin{macrocode}
+%<*cc4js>
+% \end{macrocode}
+%\section{Command Changes for JavaScript}\label{dljscc}
+% Regular expressions are a very important part of JavaScript, but they do present
+% some problems for \LaTeX. Ideally, we would like to type JavaScript code into the
+% \texttt{insDLJS} environment using standard JavaScript syntax.
+% (Whether I am successful remains to be seen.) As a result, some new definitions
+% and changes in old definitions are necessary. All definitions take place within a
+% group, so they are unknown outside the \texttt{insDLJS} environment.
+%
+%\subsection{Regular Expressions}
+% Regular expressions can be constructed in two ways, by using (1) a literal text format; or (2)
+% using the \texttt{RegExp} constructor function. The literal text format:
+%\begin{flushleft}
+%\texttt/\textsl{pattern}\texttt/\textsl{flags}
+%\end{flushleft}
+% The \texttt{RegExp} constructor method:
+%\begin{flushleft}\ttfamily
+%new RegExp("\textsl{pattern}" [, "\textsl{flags}"])
+%\end{flushleft}
+% For additional details on regular expressions, see
+%\begin{flushleft}\small
+%\url{http://developer.netscape.com/docs/manuals/js/core/jsref15/regexp.html}
+%\end{flushleft}
+% There is a further complication when dealing with regular expressions. To quote from the above
+% document:\par\medskip\noindent
+% \textbf{Description }
+% When using the constructor function, the normal string escape rules (preceding special characters with `|\|' when included in a string) are necessary.
+% For example, the following are equivalent:
+% \begin{flushleft}
+% \ttfamily\obeylines
+% re = new RegExp("\string\\w+")
+% re = /\string\w+/
+%\end{flushleft}
+%\subsection{Begin Definitions}
+% \subsubsection{Handling of Formatting Sequences}
+% The macro \cmd{\eqesc} expands to `|\|' in the case of the distiller and to `|\\|' in the
+% case of \textsf{pdftex} or \textsf{dvipdfm}. This group of special characters formats the
+% output and they require a different definition than most of the others.
+%
+% The \cs{ckivspace} (``check for space'') macro sees whether the next token is a space,
+% if yes, it absorbs it, if not, it replaces it. I implemented this in order to get
+% final output identical to the JavaScript. For example, the following is legal JavaScript
+%\begin{verbatim}
+% var str = "First line.\r\rSkip a line. // (1)
+%\end{verbatim}
+% This is a problem for \TeX. In order to delimit the macro, \TeX{} users need to write the
+% above line as
+%\begin{verbatim}
+% var str = "First line.\r\r Skip a line. // (2)
+%\end{verbatim}
+% which then introduces a spurious space into the JavaScript code. The \cs{ckivspace} solves this
+% problem, I hope. With the definition of \cs{r} given below, after expansion of the line (2)
+% occurs, we have line (1), the space following the second \cs{r} gets absorbed. Note: (2014/05/20)
+% I moved this to the main code thread of \textsf{insdljs}.
+% \changes{v2.0n}{2014/05/20}{Moved code for \cs{ckivspace} to main code thread of \textsf{insdljs}.}
+% \begin{macrocode}
+%\def\ckivspace#1{\if\noexpand#1\space\else\expandafter#1\fi}
+% \end{macrocode}
+% \begin{macro}{\r}
+% Matches a carriage return.
+% \begin{macrocode}
+\def\r{\eqesc r\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\t}
+% Matches a tab.
+% \begin{macrocode}
+\def\t{\eqesc t\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\n}
+% Matches a linefeed.
+% \begin{macrocode}
+\def\n{\eqesc n\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\f}
+% Matches a form-feed.
+% \begin{macrocode}
+\def\f{\eqesc f\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\v}
+% Matches a form-feed.
+% \begin{macrocode}
+\def\v{\eqesc v\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \subsubsection{Matching a Word Boundary or Not}
+% \begin{macro}{\b}
+% Matches a word boundary, such as a space. (Not to be confused with |[\b]|, which
+% matches a backspace.)
+% \begin{macrocode}
+\def\b{\eqesc b\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% The next group are all defined in the same way, pretty much. The macro \cmd{\eqesc} expands to `|\|'
+% in the case of the distiller options, and to `|\\\|' otherwise.
+% \begin{macro}{\B}
+% Matches a non-word boundary.
+% \begin{macrocode}
+\def\B{\eqesc B\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\cX}
+% Where X is a letter from A - Z. Matches a control character in a string. Doesn't seem to have
+% much use in Acrobat JavaScript, will comment this one out. Usage: \cs{cM}
+% \begin{macrocode}
+% \def\doAlpha{\do A\do B\do C\do D\do E\do F%
+% \do G\do H\do I\do J\do K\do K\do M\do N%
+% \do O\do P\do Q\do R\do S\do T\do U\do V\do W\do X\do Y\do Z}
+% \def\mkDefns#1{\expandafter\def\csname c#1\endcsname{\eqesc c#1}}
+% \let\do=\mkDefns\doAlpha
+% \end{macrocode}
+% \end{macro}
+% \subsubsection{Matching Digits or Not}
+% \begin{macro}{\d}
+% Matches a digit character. Equivalent to \texttt{[0-9]}.
+% \begin{macrocode}
+\def\d{\eqesc d\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\D}
+% Matches any non-digit character. Equivalent to |[^0-9]|.
+% \begin{macrocode}
+\def\D{\eqesc D\ckivspace}
+% \end{macrocode}
+% \end{macro}
+%\subsubsection{Matching Whitespaces or Not}
+% \begin{macro}{\s}
+% Matches a single white space character, including space, tab, form feed, line feed.
+% Equivalent to |[\f\n\r\t\u00A0\u2028\u2029]|.
+% \begin{macrocode}
+\def\s{\eqesc s\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\S}
+% Matches a single character other than white space.\newline
+% Equivalent to |[^ \f\n\r\t\u00A0\u2028\u2029]|.
+% \begin{macrocode}
+\def\S{\eqesc S\ckivspace}
+% \end{macrocode}
+% \end{macro}
+%\subsubsection{Matching Alphanumeric Characters or Not}
+% \begin{macro}{\w}
+% Matches any alphanumeric character including the underscore. Equivalent to |[A-Za-z0-9\_]|.
+% \begin{macrocode}
+\def\w{\eqesc w\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\W}
+% Matches any non-word character. Equivalent to |[^A-Za-z0-9_]|.
+% \begin{macrocode}
+\def\W{\eqesc W\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \subsubsection{Handling of Character Codes}
+% \begin{macro}{\xXX}
+% Matches the character with the code \texttt{XX} (two hexadecimal digits).
+% The character with the Latin-1 encoding specified by the two hexadecimal digits \texttt{XX}
+% between 00 and FF. For example, \cs{xA9} is the hexadecimal sequence for the copyright
+% symbol.
+%\begin{flushleft}
+%\textbf{Usage}
+%\begin{verbatim}
+%\x9A
+%\end{verbatim}
+%if the most significant digit is a number \texttt{[0-9]},
+%\begin{verbatim}
+%\x A9
+%\end{verbatim}
+%if the most significant digit is a letter \texttt{[a-fA-F]}
+%\end{flushleft}
+%\changes{v2.3b}{2016/10/13}{JPC reported bug with French-Babel, traced it to this code.}
+%To avoid a French-Babel clash (reported by JPC), we change \cs{catcode} of colon (:) to other, enclose in a group
+%and do \cs{xdef} instead of \cs{edef}.
+% \begin{macrocode}
+\begingroup
+\catcode`\:=12\relax
+\dljstfor\dlhex:={AA}{AB}{AC}{AD}{AE}{AF}%
+ {BA}{BB}{BC}{BD}{BE}{BF}{CA}{CB}{CC}{CD}{CE}{CF}%
+ {DA}{DB}{DC}{DD}{DE}{DF}{EA}{EB}{EC}{ED}{EE}{EF}%
+ {FA}{FB}{FC}{FD}{FE}{FF}\do{%
+ \expandafter\xdef\csname x\dlhex\endcsname{\noexpand\eqesc x\dlhex}%
+}
+\endgroup
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\uXXXX}
+% In a regular expression search, \cs{uXXXX} matches the character
+% with unicode character code \texttt{XXXX} (four hexadecimal
+% digits). For example, \cs{u00A9} is the Unicode sequence for the
+% copyright symbol. See Unicode Escape Sequences. http://www.unicode.org
+%\begin{flushleft}
+%\textbf{Usage}
+%\begin{verbatim}
+%\u00A9
+%\end{verbatim}
+%if the most significant digit is a number \texttt{[0-9]},
+%\begin{verbatim}
+%\u F0A9
+%\end{verbatim}
+%if the most significant digit is a letter \texttt{[a-fA-F]}
+%\end{flushleft}
+% \begin{macrocode}
+\def\u{\eqesc u\ckivspace}
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{\XXX}
+% The character with the Latin-1 encoding specified by up to three octal digits \texttt{XXX} between
+% 0 and 377. For example, \cs{251} is the octal sequence for the copyright symbol.
+%
+% Since this goes only up to octal 377, it suffices to make only the following four definitions.
+% \begin{macrocode}
+\def\0{\eqesc0}
+\def\1{\eqesc1}
+\def\2{\eqesc2}
+\def\3{\eqesc3}
+% \end{macrocode}
+% \end{macro}
+%\subsubsection{Other Special Characters}
+% \begin{macro}{braces}
+% Braces are a problem when they are unbalanced. In a regular expression, |\{| works properly, but |\\{| works
+% for the distiller options but not otherwise. For example, if I wanted to replace every instance
+% of \texttt{\{} with \texttt{(}, we can do this by
+%\begin{verbatim}
+% myString = myString.replace( /\{/, "\(");
+%\end{verbatim}
+% This works for all options, even though the braces are not balanced. However, when the constructor
+% function is used, we must double-escape:
+%\begin{verbatim}
+% var re = new RegExp("\\{", "g");
+% myString = myString.replace( re, "\(");
+%\end{verbatim}
+% This works for the distiller options, but not for \texttt{pdftex/dvipdfm}. The reason |\{| works is that
+% it is a control sequence, defined by the \cmd{\definebraces} command below. Where as |\\{| consists
+% of the control sequence |\\|, which is defined below, followed by a left brace.
+% \TeX{} still requires the braces to be balanced.
+%
+% If you are searching for balanced braces, there should't be a problem, for example,
+% the code
+%\begin{verbatim}
+% var re = new RegExp("\\{|\\}", "g");
+% myString = myString.replace( re, "\(");
+%\end{verbatim}
+% works correctly.
+%
+% To continue the discussion of the problem with searching for
+% unbalanced braces, one workaround is to balance out the left
+% brace with a right brace in the form of a JavaScript comment.
+% This ``fools'' \TeX! For example,
+%\begin{verbatim}
+% var re = new RegExp("\\{", "g"); // }
+% myString = myString.replace( re, "\(");
+%\end{verbatim}
+% Finally, we have\par\medskip
+% \noindent\textbf{The Recommended Workaround:} Use |\\\{| and |\\\}|, e.g.,
+%\begin{verbatim}
+% var re = new RegExp("\\\{", "g");
+% myString = myString.replace( re, "\(");
+%\end{verbatim}
+% This is more verbose than needed, but it works for all options! These comments are only for regular expression
+% strings within the constructor function. Note the replacement text, |\(|, is only escaped.
+%
+% Here we make the definitions for left and right braces. See the definition of \cs{definebraces}
+% given earlier.
+% \begin{macrocode}
+\definebraces
+% \end{macrocode}
+% \end{macro}
+% \begin{macro}{parentheses}
+% Just as braces can give us problems with \TeX, so too, parentheses can give us problems with
+% Acrobat JavaScript interpreter. There seems to be a requirement that parentheses be balanced
+% unless they are properly escaped. Generally, we have no problems in the case of distiller options,
+% once again \textsf{pdftex} and \textsf{dvipdfm} are causing (me) problems.
+%
+% No problems when the regular expression uses the literal string format
+%\begin{verbatim}
+% myString = myString.replace(/\(/g, "\[");
+%\end{verbatim}
+% The above code works for all options. However, for the constructor function we have some problems
+% in non-distiller options. If we type instead
+%\begin{verbatim}
+% var re = new RegExp("\\(", "g");
+% myString = myString.replace(re, "\[");
+%\end{verbatim}
+% The above code works for the distiller folks, but not for the
+% others. In the case of \textsf{pdftex}, I cannot access the UI to
+% the document level JavaScripts, and the script is undefined. I suspect
+% the lack of balanced parentheses is the curprit. For example,
+% consider the code
+%\begin{verbatim}
+% var re = new RegExp("\\(|\\)", "g");
+% myString = myString.replace(re, "\[");
+%\end{verbatim}
+% works. I can access the UI to the DLJS from Acrobat, and the script is defined. Another
+% example, we can fool the JavaScript interpreter as we did the \TeX{} compiler:
+%\begin{verbatim}
+% var re = new RegExp("\\(", "g"); // )
+% myString = myString.replace(re, "\[");
+%\end{verbatim}
+% Here I have placed a balancing right parenthesis as a JavaScript comment. Both sets of code
+% work correctly.
+%\par\medskip
+%\noindent\texttt{Recommended Workaround:} As in the case of parentheses, a more verbose version
+% of the script works of all options.
+%\begin{verbatim}
+% var re = new RegExp("\\\(", "g");
+% myString = myString.replace(re, "\[");
+%\end{verbatim}
+% This is only for the case of the constructor function.
+% \begin{macrocode}
+\def\({\eqesc\eqesci(}
+\def\){\eqesc\eqesci)}
+% \end{macrocode}
+% \end{macro}
+% The rest of these definitions are for characters that have a
+% special meaning when they appear in a regular expression. See
+%\begin{flushleft}\small
+%\url{http://developer.netscape.com/docs/manuals/js/core/jsref15/regexp.html}
+%\end{flushleft}
+% for a description of the meaning for the special characters given below (and above).
+% To ``escape'' the special meaning of any character, ``escape'' them.
+% \begin{macrocode}
+\def\.{\eqesc.}
+\def\/{\eqesc/}
+\def\[{\eqesc[}
+\def\]{\eqesc]}
+% \end{macrocode}
+% \begin{macrocode}
+\def\|{\eqesc|}
+\def\+{\eqesc+}
+\def\*{\eqesc*}
+\def\-{\eqesc-}
+\def\?{\eqesc?}
+\def\${\eqesc$}
+\def\^{\eqesc^}
+\def\\{\eqesc\eqesc}
+% \end{macrocode}
+% The next group of characters have no special meaning in a regular expression, but are using elsewhere
+% in JavaScript. These definitions may come in handy.
+% \begin{macrocode}
+\def\'{\eqesc'}
+% \end{macrocode}
+% The \texttt{german} package makes doublequotes, |"|, active, so within the \texttt{insDLJS}
+% environment, we change its catcode to 12.
+% \begin{macrocode}
+\catcode`\"=12
+\def\"{\eqesc"}
+% \end{macrocode}
+% We de-activate angle brackets.
+% \begin{macrocode}
+\catcode`\<=12
+\def\<{\eqesc<}
+\catcode`\>=12
+\def\>{\eqesc>}
+% \end{macrocode}
+% Here, we define `\texttt{\%}' differently. The percent has no special meaning in regular expressions,
+% but is used by the \texttt{util.printf()} method.
+% \begin{macrocode}
+\catcode`\%=12
+\def\%{%}
+\catcode`\%=14
+% \end{macrocode}
+% The `and' symbol has not special meaning for regular expressions, but is used as a logical `and'.
+% Probably don't need this escape.
+% \begin{macrocode}
+\catcode`\& = 12
+\def\&{\eqesc&}
+% \end{macrocode}
+% \begin{macrocode}
+%</cc4js>
+% \end{macrocode}
+% \begin{macrocode}
+%<*altadbfncs>
+% \end{macrocode}
+% \section{Alternate names for some Adobe functions}\label{s:AltAdbFncs}
+% (2017/03/02) Added alternate names for some common Adobe functions. Used for
+% creating custom keystroke and formatting events.
+% \changes{v2.3f}{2017/03/02}{Alternate names for Adobe functions added}
+% \begin{macrocode}
+\begin{insDLJS}{altadbfncs}{eforms: Alternate Adobe Function Names}
+var EFNumber_Keystroke=AFNumber_Keystroke;
+var EFNumber_Format=AFNumber_Format;
+var EFPercent_Keystroke=AFPercent_Keystroke;
+var EFPercent_Format=AFPercent_Format;
+var EFDate_Format=AFDate_Format;
+var EFDate_Keystroke=AFDate_Keystroke;
+var EFDate_FormatEx=AFDate_FormatEx;
+var EFTime_Keystroke=AFTime_Keystroke;
+var EFTime_Format=AFTime_Format;
+var EFTime_FormatEx=AFTime_FormatEx;
+var EFDate_KeystrokeEx=AFDate_KeystrokeEx;
+var EFSpecial_Keystroke=AFSpecial_Keystroke;
+var EFSpecial_Format=AFSpecial_Format;
+var EFSpecial_KeystrokeEx=AFSpecial_KeystrokeEx;
+var EFRange_Validate=AFRange_Validate;
+var EFRange_Validate=AFRange_Validate;
+var EFSimple_Calculate=AFSimple_Calculate;
+var EFMergeChange=AFMergeChange;
+\end{insDLJS}
+%</altadbfncs>
+% \end{macrocode}
+% \begin{macrocode}
+%<*package>
+\inputAltAdbFncs
+%</package>
+% \end{macrocode}
+% \Finale
+%\endinput