YaTeX automates typesetting and previewing of LaTeX and enables
completing input of LaTeX mark-up command such as
\begin{}..\end{}.
YaTeX also supports Demacs which runs on MS-DOS(386), Mule (Multi Language Enhancement to GNU Emacs), and latex on DOS.
\includeonly
\begin{},
\section etc.
(C-c b, C-c s, C-c l, C-c m)
Put next two expressions into your `~/.emacs'.
(setq auto-mode-alist
(cons (cons "\\.tex$" 'yatex-mode) auto-mode-alist))
(autoload 'yatex-mode "yatex" "Yet Another LaTeX mode" t)
Next, add certain path name where you put files of YaTeX to your load-path. If you want to put them in `~/src/emacs', write
(setq load-path
(cons (expand-file-name "~/src/emacs") load-path))
in your `~/.emacs'
Then, yatex-mode will be automatically loaded when you visit a file which has extension `.tex'. If yatex-mode is successfully loaded, mode string on mode line will be turned to "YaTeX".
The prefix key stroke of yatex-mode is C-c (Press 'C' with Control key) by default. If you don't intend to change the prefix key stroke, assume all [prefix] as C-c in this document. These key strokes execute typeset or preview command.
Typing [prefix] t j, the current editing window will be divided horizontally when you invoke latex command, and log message of LaTeX typesetting will be displayed in the other window; called typesetting buffer. The typesetting buffer automatically scrolls up and traces LaTeX warnings and error messages. If you see latex stopping by an error, you can send string to latex in the typesetting buffer.
If an error stops the LaTeX typesetting, this key stroke will move the cursor to the line where LaTeX error is detected.
If you find a noticeable error, move to the typesetting buffer and move the cursor on the line of error message and type SPACE key. This makes the cursor move to corresponding source line.
YaTeX-typeset-region invoked by [prefix] tr call typesetter
for region. The region is specified by standard point and mark, or
by %#BEGIN and %#END marks. Selected region will be
copied to the temporary file `texput.tex' with the same preamble
as the main file of current editing sources. Be sure to put
all local macro settings in preamble, not after \begin{document}.
The method of specification of the region is shown in the
section See section %# notation.
The documentclass for typeset-region is the same as that of editing file if you edit one file, and is the same as main file's if you edit splitting files.
The [prefix] te key automatically marks current inner environment or inner math mode or paragraph, and then call typeset-region with marked region. This is convenient to quick view of current tabular environment or current editing formulas. If running Emacs has the ability of displaying images, typeset image will be shown in the next window. Further more, if you modify the content within that environment, YaTeX performs `on-the-fly' preview that automatically update preview image as you typed.
If your Emacs does not supply on-the-fly preview, keeping previewer window for `texput.dvi' is handy for debugging. Since [prefix] te selects the inner-most environment as region, it is not suitable for partial typesetting of doubly or more composed environment. If you want to do partial typesetting for a nested environment, use [prefix] tr for static-region, which is described in the section See section %# notation.
[prefix] t p invokes the TeX previewer. And if you are using xdvi-remote, which can be controled from other terminals, [prefix] t s enables you to search current string at the cursor on the running xdvi window.
When you type [preifx] t l, YaTeX asks you the range of
dvi-printing by default. You can skip this by invoking it with
universal-argument as follows:
C-u [prefix] tl
You can control the typesetting process by describing %#
notations in the source text.
To change the typesetting command, write
%#!latex-big
anywhere in the source text. This is useful for changing typesetter.
And if you split the source text and edit subfile that should be included from main text.
%#!latex main.tex
will be helpful to execute latex on main file from sub text buffer. Since this command line after %#! will be sent to shell literally, next description makes it convenient to use ghostview as dvi-previewer.
%#!latex main && dvi2ps main.dvi > main
Note that YaTeX assumes the component before the last period of
the last word in this line as base name of the main LaTeX source.
The %f notation in this line is replaced by main file name, and
%r replaced by root name of main file name. If you specify
%f or %r, YaTeX always ask you the name of main file at the
first typesetting.
To make best use of the feature of inter-file jumping by [prefix] g (see section Cursor jump), take described below into consideration.
%#!latex main.tex even if `main.tex'
is in the parent directory(not %#!latex ../main.tex).
Typeset-region by [prefix] tr passes the region between point and
mark to typesetting command by default. But when you want to typeset
static region, enclose the region by %#BEGIN and %#END as
follows.
%#BEGIN
TheRegionYouWantToTypesetManyTimes
%#END
This is the rule of deciding the region.
It is useful to write %#BEGIN in the previous line of \begin and
%#END in the next line of \end when you try complex
environment such as `tabular' many times. It is also useful to put only
%#BEGIN alone at the middle of very long text. Do not forget to
erase %#BEGIN %#END pair.
Lpr format is specified by three Lisp variables. Here are the default values of them.
(1)dviprint-command-format
"dvi2ps %f %t %s | lpr"
(2)dviprint-from-format
"-f %b"
(3)dviprint-to-format
"-t %e"
On YaTeX-lpr, %s in (1) is replaced by the file name of main
text, %f by contents of (2), %t by contents of (3). At these
replacements, %b in (2) is also replaced by the number of beginning
page, %e in (3) is replaced by the number of ending page. But
%f and %t are ignored when you omit the range of print-out
by C-u [prefix] tl.
If you want to change this lpr format temporarily, put a command such as follows somewhere in the text:
%#LPR dvi2ps %f %t %s | 4up -page 4 | texfix | lpr -Plp2
And if you want YaTeX not to ask you the range of printing out, the next example may be helpful.
%#LPR dvi2ps %s | lpr
These %# notation below can control which command to invoke for LaTeX related process.
If you want to invoke "makeidx hogehoge" to update index, put the next line some upper place in the source, for example.
%#MAKEINDEX makeidx hogehoge
To edit %# notation described above, type
and select one of the entry of the menu as follows.
!)Edit-%#! B)EGIN-END-region L)Edit-%#LPR
Type ! to edit %#! entry, b to enclose the region with
%#BEGIN and %#END, and l to edit %#LPR entry.
When you type b, all %#BEGIN and %#END are
automatically erased.
YaTeX makes it easy to input the LaTeX commands. There are several kinds of completion type, begin-type, section-type, large-type, etc...
"Begin-type completion" completes commands of \begin{env} ...
\end{env}. All of the begin-type completions begin with this key
sequence.
An additional key stroke immediately completes a frequently used
LaTeX \begin{}...\ environment.
end{}
\begin{center}...\end{center}
\begin{document}...\end{document}
\begin{description}...\end{description}
\begin{enumerate}...\end{enumerate}
\begin{equation}...\end{equation}
\begin{itemize}...\end{itemize}
\begin{flushleft}...\end{flushleft}
\begin{minipage}...\end{minipage}
\begin{tabbing}...\end{tabbing}
\begin{tabular}...\end{tabular}
\begin{table}...\end{table}
\begin{picture}...\end{picture}
\begin{quote}...\end{quote}
\begin{quotation}...\end{quotation}
\begin{flushright}...\end{flushright}
\begin{verbatim}...\end{verbatim}
\begin{verse}...\end{verse}
Any other LaTeX environments are made by completing-read of the Emacs function.
The next message will show up in the minibuffer
Begin environment(default document):
by typing [prefix] b. Put the wishing environment with completion
in the minibuffer, and \begin{env}...\\end{env} will be
inserted in the LaTeX source text. If the environment you want to put
does not exist in the YaTeX completion table, it will be registered in the
user completion table. YaTeX automatically saves the user completion
table in the user dictionary file at exiting of emacs.
At the completion of certain environments, the expected initial entry will
automatically inserted such as \item for itemize
environment. If you don't want the entry, it can be removed by undoing.
If you want to enclose some paragraphs which have already been written into environment, invoke the begin-type completion right after region marking.
If you set transient-mark-mode to nil in your
`~/.emacs', typing C-space (set-mark-command) twice
turns transient-mark-mode on temporarily. Then, type call
begin-type completion to enclose text into a environment.
"Section-type completion" completes section-type commands which take an
argument or more such as \section{foo}. To invoke section-type
completion, type
then the prompt
(C-v for view) \???{} (default documentclass):
will show up in the minibuffer. Section-type LaTeX commands are completed by space key, and the default value is selected when you type nothing in the minibuffer.
Next,
\section{???}:
prompts you the argument of section-type LaTeX command. For example, the following inputs
\???{} (default documentclass): section
\section{???}: Hello world.
will insert the string
\section{Hello world.}
in your LaTeX source. When you neglect argument such as
(C-v for view) \???{} (default section): vspace*
\vspace*{???}:
YaTeX puts
\vspace*{}
and move the cursor in the braces.
In LaTeX command, there are commands which take more than one
arguments such as \addtolength{\topmargin}{8mm}. To complete these
commands, invoke section-type completion with universal argument as,
C-u 2 [prefix] s (or ESC 2 [prefix] s)
and make answers in minibuffer like this.
(C-v for view) \???{} (default vspace*): addtolength
\addtolength{???}: \topmargin
Argument 2: 8mm
\addtolength and the first argument \topmargin can be typed
easily by completing read. Since YaTeX also learns the number of
arguments of section-type command and will ask that many arguments in
future completion, you had better tell the number of arguments to YaTeX at
the first completion of the new word. But you can change the number of
arguments by calling the completion with different universal argument
again.
Invoking section-type completion with [Prefix] S (Capital `S')
includes the region as the first argument of section-type command.
The section/large/maketitle type completion can work at the prompt for the argument of other section-type completion. Nested LaTeX commands are efficiently read with the recursive completion by typing YaTeX's completion key sequence in the minibuffer.
In the minibuffer at the prompt of section-type command completion,
typing C-v shows a list of sectioning commands in source text(The
line with <<-- mark is the nearest sectioning command). Then,
default sectioning command appears in the minibuffer. You can go up/down
sectioning command by typing C-p/C-n, can scrolls up/down the
listing buffer by C-v/M-v, and can hide sectioning commands
under certain level by 0 through 6. Type ? in the minibuffer of
sectioning prompt for more information.
You can generate this listing buffer (*Sectioning Lines* buffer)
by typing
@cindex{Generate the listing of sectioning units}
from the LaTeX source buffer. In this listing buffer, typing u on
the sectioning command shifts up the corresponding sectioning command in
source text and d shifts down. After marking lines in the listing
buffer, typing U shifts up all sectioning commands in the region,
and U shifts down. Here are all the key bindings of
*Sectioning Lines* buffer.
When you want to type-in references of \ref or \cite,
all you have to do is type [prefix] s ref without adding labels
beforehand. You will see possible LaTeX-counters in the next window
even if some counter does not have \label. Selecting the counter
will automatically set the label to that counter.
All possible counter list in the buffer tends to be large. You can reduce the number of list by filtering type of counters by key-commands as follows.
"Large-type completion" inputs the font or size changing
descriptions such as {\large }. When you type
the message in the minibuffer
{\??? } (default large):
prompts prompts you large-type command with completing-read. There are
TeX commands to change fonts or sizes, it, huge and so on,
in the completion table.
Region-based completion is also invoked by calling completion after region activated.
We call it "maketitle-type completion" which completes commands such as
\maketitle. Take notice that maketitle-type commands take no
arguments. Then, typing
begins maketitle-completion. Above mentioned method is true for maketitle-completion, and there are LaTeX commands with no arguments in completion table.
You can complete certain LaTeX command anywhere without typical completing method as described, by typing
after the initial string of LaTeX command that is preceded by \.
YaTeX automatically detects the opened environment and close it with
\\end{environment}. Though proficient YaTeX users never fail to
make environment with begin-type completion, some may begin an environment
manually. In that case, type
end completion
at the end of the opened environment.
When you want to write the European accent marks(like \`{o}),
shows the menu
1:` 2:' 3:^ 4:" 5:~ 6:= 7:. u v H t c d b
in the minibuffer. Chose one character or corresponding numeric, and you will see
\`{}
in the editing buffer with the cursor positioned in braces. Type one more character `o' for example, then
\`{o}
will be completed, and the cursor gets out from braces.
Arrow marks, sigma mark and those signs mainly used in the TeX's math environment are completed by key sequences which imitate the corresponding symbols graphically. This completion only works in the math environment. YaTeX automatically detects whether the cursor located in math environment or not, and change the behavior of key strokes ; and :.
By the way, we often express the leftarrow mark by `<-' for example.
Considering such image, you can write \leftarrow by typing <-
after ; (semicolon) as a prefix. In the same way,
\longleftarrow (<--) is completed by typing ;<--,
infinity mark which is imitated by oo is completed by typing
;oo.
Here are the sample operations in YaTeX math-mode.
INPUT Completed LaTeX commands ; < -\leftarrow; < - -\longleftarrow; < - - >\longleftrightarrow; o\circ; o o\infty
In any case, you can quit from image completion and can move to the next editing operation if the LaTeX command you want is shown in the buffer.
; itself in math-environment is inserted by ;;. Typing
TAB in the midst of image completion shows all of the LaTeX
commands that start with the same name as string you previously typed in.
In this menu buffer, press RET after moving the cursor (by n,
p, b, f) to insert the LaTeX command.
To know all of the completion table, type TAB just after ;. And here is the sample menu by TAB after ;<.
KEY LaTeX sequence sign
< \leq <
~
<< \ll <<
<- \leftarrow <-
<= \Leftarrow <=
You can define your favorite key-vs-sequence completion table in the
Emacs-Lisp variable YaTeX-math-sign-alist-private. See also
`yatexmth.el' for the information of the structure of this variable.
Math-mode of YaTeX provides another image completion, Greek letters
completion in the same method. After prefix :, typing a makes
\alpha, b makes \beta and g makes \gamma
and so on. First, type :TAB to know all the correspondence of
alphabets vs. Greek letters.
If you will find ; or : doesn't work in correct position of math environment, it may be a bug of YaTeX. Please send me a bug report with the configuration of your text, and avoid it temporarily by typing ; or : after universal-argument(C-u) which forces ; and : to work as math-prefix.
Typing opening parenthesis, one of (, { and ,
automatically inserts the closing one. If a opening bracket is typed
after [\, \] is automatically inserted with computed
indentation. If you stop automatic insertion, type C-q before
opening parenthesis.
Tables for completion consist of three dictionaries; `standard dictionary' built in `yatex.el', `user dictionary' for your common private commands, and `local dictionary' that is effective in a certain directory.
When you input the command unknown to YaTeX at a completion in the minibuffer, YaTeX asks you with the following prompt;
`foo' is not in table. Register into: U)serDic L)ocalDic N)one D)iscard
In this menu, typing u updates your `user dictionary', l updates your local dictionary, n updates only on-memory dictionary which go through only current Emacs session, and d updates no dictionary and throws the new word away.
If you find this switching feature meaningless and bothersome, put the next expression into your `~/.emacs'
(setq YaTeX-nervous nil)
You may want to comment out some region.
cause an operation to the region between point and mark.
comments or uncomments the paragraph where the cursor belongs. This `paragraph' means the region marked by the function mark-paragraph, bound to ESC h by default. It is NOT predictable what will happen when you continuously comment out some paragraph many times.
You can also comment out an environment between \begin and
\end, or a \begin-\\end pair themselves, by making the
following key strokes on the line where \begin{} or
\end{} exists.
end
end
comment whole the contents of environment. Moreover,
end
end
(un)comments out only environment declaration: \begin{} and
\end{}. NOTE that even if you intend to comment out some region,
invoking [prefix] > on the \begin,\end line decides to
work in `commenting out from \begin to \end' mode.
Typing
in a certain place move the cursor to the place corresponding to the LaTeX command of last place. YaTeX recognize the followings as pairs that have relation each other.
\begin{} <-> \end{}
%#BEGIN <-> %#END
\label{} <-> \ref{}
\include(\input) -> included file
\bibitem{} <-> \cite{}
On a \begin,\end line, typing [prefix] g moves the
cursor to the corresponding \end,\begin line, if its partner
really exists. The behavior on the line %#BEGIN and %#END
are the same. Note that if the correspondent of label/ref or
cite/bibitem exists in another file, that file have to be opened to
make a round trip between references by [prefix] g.
If you type [prefix] g on the line of \include{chap1},
typically in the main text, YaTeX switches buffer to `chap1.tex'.
do the same job as [prefix] g except it's done in other window.
Note that this function doesn't work on begin/end,
%#BEGIN/%#END pairs because it is meaningless.
@cindex{Drawing tool invocation}
`image-including line' described above means such lines as
\epsfile{file=foo.ps}. If you type [prefix] g on that
line, YaTeX automatically searches source of `foo.ps' and invokes image
viewer or drawing tool correspoinding to it. For example; if you draw
an image foo.obj with Tgif and enclose its product named foo.eps by
\epsfile command. Typing [prefix] g on \epsfile line
make YaTeX invoke tgif foo.obj. How a processor is choosen is as
follows.
YaTeX-processed-file-regexp-alist, extract file name
from regexp group surrounded by \\(\\). (Which group corresponds is
written in the cdr part of each list.) If no matches were found, do
nothing.
YaTeX-file-processor-alist, call that processor giving the
file name with corresponding extension.
YaTeX-file-processor-alist. If any, call the corresponding
image viewer or drawing tool.
Typing
in a sub text switch the buffer to the main text specified by
%#! notation.
And these are the functions which work on the current LaTeX environment:
end of environment
YaTeX always memorize the position of completion into register 3.
So every time you make a trip to any other part of text other than you are
writing, you can return to the editing paragraph by calling
register-to-point with argument YaTeX-current-position-register, which is
achieved by typing C-x j 3(by default).
These functions are for change or deletion of LaTeX commands already entered.
[prefix] c can change the various (La)TeX commands. This can change the followings.
Typing [prefix] c on one of above objects you want to change brings a suitable reading function sometimes with completion. Note: If you want to change the argument of section-type command that contains other LaTeX commands, type [prefix] c either of surrounding braces of the argument in order to make YaTeX ignore the internal LaTeX sequences as an object of changing. Anyway, it is very difficult to know which argument position the cursor belongs because the LaTeX commands can be nested and braces can freely emerge. So keep it mind to put the cursor on a brace when you are thinking of changing a complicated argument.
[prefix] k kills the LaTeX commands sometimes with their arguments. Following table illustrates the correspondence of the invoking position and what is killed.
[Invoking position] [action] \begin, \end line kill \begin,\end pairs %#BEGIN, %#END line kill %#BEGIN,%#END pairs on a Section-type command kill section-type command on a parenthesis kill parentheses
Note that when killing \begin, \end or %#BEGIN, %#END pair,
the lines \begin, \end or %#BEGIN, %#END exist will be
killed entirely. So take care not to create any line that contains more
than one \begin or so.
While all operations above are to kill `containers' which surround some text, universal argument (C-u) for these commands kills not only `containers' but also `contents' of them. See below as a sample.
Original text: [prefix] k C-u [prefix] k
Main \footnote{note} here. Main note here. Main here.
~(cursor)
To fill a term (descriptive sentences) of \item, type
on that item.
YaTeX uses the value of the variable YaTeX-item-regexp as the
regular expression to search item header in itemize environment.
If you make a newcommand to itemize terms(e.g. \underlineitem), put
(setq YaTeX-item-regexp
"\\(\\\\\\(sub\\)*item\\)\\|\\(\\\\underlineitem\\)")
in your `~/.emacs'. If you are not familiar with regular expression
for Emacs-Lisp, name a newcommand for `itemize' beginning with
\item such as \itembf, not \bfitem.
This function reformats the \item into `hang-indented' style.
For example:
itemize, enumerate environment:
>
>\item[foo] `foo' is the typical word for describing an
> arbitrarily written....
description environment:
> \item[bar] When the word `for' is used as an arbitrarily
> word, `bar' is bound to follow it.
Note that the indent depth of an \item word and its descriptive
paragraph are the same in latter case. If you want to use different
depth, invoke fill-paragraph at the beginning of non-whitespace
character(see below).
Fill-paragraph is little bit adapted for LaTeX sources. It retains from
filling in certain environments where formatting leads to a disaster such
as verbatim, tabular, or so. And it protects \verb expressions
from being folded (The variable YaTeX-verb-regexp controls this).
Besides, putting cursor on the first occurrence of non-whitespace
character on a line changes the fill-prefix temporarily to the depth of
the line.
\includeonlyWhen you edit splitting source texts, the notation
\includeonly{CurrentEditingFileName}
in the main file reduces the time of typesetting. If you want to hack other file a little however, you have to rewrite it to
\includeonly{OtherFileNameYouWantToFix}
in the main file. YaTeX automatically detects that the current edited text is not in includeonly list and prompts you
A)dd R)eplace %)comment?
in the minibuffer. Type a if you want to add the current file name
to \includeonly list, r to replace \includeonly list
with the current file, and type % to comment out the
\includeonly line.
We are often get tired of finding the corresponding column in large tabulars. For example,
\begin{tabular}{|c|c|c|c|c|c|c|c|}\hline
Name&Position&Post No.&Addr.&Phone No.&FAX No.&
Home Addr.&Home Phone\\ \hline
Thunder Bird & 6 & 223 & LA & xxx-yyy &
zzz-www & Japan & 9876-54321 \\
& 2 & \multicolumn{2}{c|}{Unknown}
&&&(???)
\\ \hline
\end{tabular}
Suppose you have the cursor located at (???) mark, can you tell
which column it is belonging at once? Maybe no. In such case,
type
in that position. YaTeX tells you the column header of the
current field. Since YaTeX assumes the first line of tabular
environment as a row of column headers, you can create a row of
virtual column headers by putting them in the first line and
commenting that line with %.
At the end of begin-type completion of tabular[*], array, itemize, enumerate or tabbing environment, or typing
in these environments inserts the contents corresponding to the current
environment in the next line. (At the begin-type completion, this
contents can be removed by `undo'.) In tabular environment, for
example, ESC RET inserts the certain number of & and trailing
\\, and \hline if other \hline is found in backward.
Here are the list of contents vs. environments.
tabular, tabular*, array
Corresponding number of & and \\.
And \hline if needed.
tabbing
The same number of \> as \= in the first line.
itemize, enumerate, description, list
\item or item[].
Note that since this function works seeing the contents of the first line, please call this after the second line if possible.
If you want to apply these trick to other environments, foo
environment for example, define the function named
YaTeX-intelligent-newline-foo to insert corresponding contents.
That function will be called at the beginning of the next line after the
newline is inserted to the current line. Since the function
YaTeX-indent-line is designed to indent the current line properly,
calling this function before your code to insert certain contents must be
useful. See the definition of the function
YaTeX-intelligent-newline-itemize as an example.
When you input begint-type, section-type, maketitle-type macros with
completion, and it requires some LaTeX2e package, YaTeX examines
the existence of correct \usepackage. If not, YaTeX inserts
the \usepackage{} declaration corresponding to input macro.
To activate the package completion for your favarite package,
set the variable YaTeX-package-alist-private correctly.
Please refere the value of YaTeX-package-alist-default as an
example.
YaTeX provides you the online help with popular LaTeX commands.
Here are the key strokes for the online help.
`Online help' shows the documentation for the popular LaTeX
commands(defaults to the commands on the cursor) in the next buffer.
There are two help file, `global help' and `private help'. The former
file contains the descriptions on the standard LaTeX command and is
specified its name by variable YaTeX-help-file. Usually, the
global help file should be located in public space ($EMACSEXECPATH
by default) and should be world writable so that anyone can update it to
enrich its contents. The latter file contains descriptions on
non-standard or personal command definitions and is specified by
YaTeX-help-file-private. This file should be put into private
directory.
`Online apropos' is an equivalent of GNU Emacs's apropos. It shows all the documentations that contains the keyword entered by the user.
If there is no description on a command in help files, YaTeX requires you to write a description on that command. If you are willing to do, determine which help file to add and write the description on it referring your manual of (La)TeX. Please send me your additional descriptions if you describe the help on some standard commands. I might want to include it in the next distribution.
When you are editing multi-file source, typing
asks you the parent-most file (which may be defaulted) and displays the documentation hierarchy in the next window. In this buffer, the following commands are available.
Note that operations on the file contents in the next window do not work correctly when you close the corresponding file.
YaTeX works better with other brilliant packages.
When you are loading `gmhist.el' and `gmhist-mh.el', you can use independent command history list at the prompt of preview command ([prefix] tp) and print command ([prefix] tl). On each prompt, you can enter the previous command line string repeatedly by typing M-p.
`min-out', the outline minor mode, can be used in yatex-mode buffers. If you want to use it with YaTeX, please refer the file `yatexm-o.el' as an example.
You can customize YaTeX by setting Emacs-Lisp variables and by making add-in functions.
You can change the key assignments or make completion more comfortable by setting the values of various variables which control the movement of yatex-mode.
For example, if you want to change the prefix key stroke from C-c
to any other sequence, set YaTeX-prefix to whatever you want to use. If
you don't want to use the key sequence C-c letter which is assumed
to be the user reserved sequence in Emacs world, set
YaTeX-inhibit-prefix-letter to t, and all of the default key
bind of C-c letter will turn to the corresponding C-c C-letter
(but the region based completions that is invoked with C-c
Capital-letter remain valid, if you want to disable those bindings, set
that variable to 1 instead of t).
Here are the customizable variables of yatex-mode. Each value setq-ed in `~/.emacs' is preferred and that of defined in `yatex.el' is neglected. Parenthesized contents stands for the default value. When you are to change some of these variables, see more detailed documentation of the variable by M-x describe-variable.
Depends on Japanese feature of Emacs)
1 or 2)
nil)
nil)
"~/.yatexrc")
"latex")
"xdvi -geo +0+0 -s 4")
"dvi2ps %f %t %s | lpr")
"-f %b")
end page ("-t %e")
"makeindex" ("makeind" on MS-DOS))
"dvipdfmx")
Nil disables on-the-fly preview.
'YaTeX-typeset-environment-by-lmp
which calls latex-math-preview-expression function if latex-math-preview
is available, otherwise 'YaTeX-typeset-environment-by-builtin which
alls built-in function).
Nil disables on-the-fly preview.
\nonstopmode{} or not (nil)
"line.* [0-9]*")
"l\\.[1-9][0-9]*")
"Emergency stop")
"\\\\item")
"verb\\*?\\|path")
t)
"\\(part\\|chapter\\*?\\|\\(sub\\)*\\(section\\|paragraph\\)\\*?\\)\\b")
'("tabular" "tabular*" "array" "picture" "eqnarray" "eqnarray*" "equation" "math" "displaymath" "verbatim" "verbatim*"))
% (nil)
nil for only eol
(t)
t)
nil). See `yatexmth.el'
for the information about how to define a completion alist.
nil for half height (10)
nil)
(assq 'yatex-mode hilit-patterns-alist) and the value of
YaTeX-hilit-pattern-adjustment-default (and even the document of
hilit19.el).
YaTeX-display-hierarchy searches for sectioning command first, and
comment line secondary as a file headings. In latter case, ignore lines
that match with regular expression of this variable. Default value of
this variable is RCS header expressions and mode specifying line `-*- xxxx
-*'.
nil)
\include line,
open the target file even if the file doesn't exist (nil)
nil)
\part macro. The default value is '(yellow/dodgerblue
yellow/slateblue). The first element of this list is for the screen when
hilit-background-mode is 'light, and the second element is
for 'dark. You should specify both color as `forecolor/backcolor'.
\subparagraph compared with that of \chapter
('(15 40)) See also YaTeX-hilit-sectioning-face.
t (nil)
t (t)
~/work/template.tex)
t)
(featurep 'font-lock)
(featurep 'hilit19)
t if Emacs-20 or later). This variable is effective only when
font-lock is used.
((featurep 'hilit19)
"{}" is recommended.
'((PackageName1
(completionType ListOfMacro)
(completionType ListOfMacro))
(PackageName2
(completionType ListOfMacro)
(completionType ListOfMacro...))....)
completionType is one of env, section, maketitle.
Consult the value of YaTeX-package-alist-default as an example.
(setq YaTeX-ref-generate-label-function 'my-yatex-generate-label)
(defun my-yatex-generate-label (command value)
(and (string= command "caption")
(re-search-backward "\\\\begin{\\(figure\\|table\\)}" nil t)
(setq command (match-string 1)))
(let ((alist '(("chapter" . "chap")
("section" . "sec")
("subsection" . "subsec")
("figure" . "fig")
("table" . "tbl"))))
(if (setq command (cdr (assoc command alist)))
(concat command ":" value)
(YaTeX::ref-generate-label nil nil))))
For instance, to change the prefix key stroke to ESC, and name of
the user dictionary `~/src/emacs/yatexrc', and set fill-prefix
to single TAB character, add the following setq to `~/.emacs'.
(setq YaTeX-prefix "\e"
YaTeX-user-completion-table "~/src/emacs/yatexrc"
YaTeX-fill-prefix " ")
More customizations will be done by the hook-function defined in
hook-variable yatex-mode-hook. This is useful to define a shortcut
key sequence to enter some environments other than document and
enumerate etc. The following statement defines [prefix] ba
to enter \begin{abstract} ... =end{abstract}
immediately.
(setq yatex-mode-hook
'(lambda() (YaTeX-define-begend-key "ba" "abstract")))
You should use functions YaTeX-define-key, or
YaTeX-define-begend-key to define all the key sequences of
yatex-mode.
You can stuff all of YaTeX related expressions into a file named
`yatexhks.el' if you have a lot of codes. YaTeX automatically load
this file at the initialization of itself. Using `yatexhks.el'
makes yatex-mode-load-hook unnecessary.
You can easily define a function to input detailed arguments with completion according to LaTeX environments or commands.
When you input tabular environment, don't you think "I want
YaTeX to complete its argument toward my favorite one such as
{|c|c|c|}..."? Yes, you can define the function to complete
arguments for any environment and any LaTeX commands.
Here is the procedure to define add-in functions.
There are three types of add-in.
Option add-in returns the
LaTeX's optional parameters such as optional strings after
\begin{ENV}, optional strings between a section-type command
and its first argument, and optional strings just after type
maketitle-type command. The following illustrates the name of add-in
functions, where underlined strings are generated by add-in functions.
\begin{table}[ht] (Function name: YaTeX:table)
~~~~
\put(100,200){} (Function name: YaTeX:put)
~~~~~~~~~
\sum_{i=0}^{n} (Function name: YaTeX:sum)
~~~~~~~~~~
Obviously, the function name is decided by concatenating the prefix `YaTeX:' and LaTeX command's name.
Another add-in type is argument add-in, which completes arguments for section-type commands.
\newcommand{\foo}{bar} (Function name: YaTeX::newcommand)
~~~~ ~~~
When the section-type command is inputted, the function named by concatenating `YaTeX::' and section-type command, is called automatically with an integer argument which indicates which argument of section-type command is being read. Thus the add-in should determine the job referring the value of its argument.
enclosing add-in is for modifying and/or checking the region that
will be enclosed by section-type commands via [prefix] S. An
enclosing add-in function will be called with two arguments, beginning of
the enclosed region and end of the region. Suppose you want to enclose
the existing text (a+b)/c by \frac{}.
a/c | | A B
You do set-mark-command at point A and then move to point B. Typing
[prefix] S and input frac enclose the region like this;
\frac{a/c}
Normally, the expression a/c is translated to
\frac{a}{c}. An enclosing add-in is useful for modifying
/ to }{.
If you want {|c|c|c|} for all tabular environment,
(defun YaTeX:tabular ()
"{|c|c|c|}")
is enough. If you want more complicated format, define as below.
(defun YaTeX:tabular ()
"{@{\\vrule width 1pt\\ }|||@{\\ \\vrule width 1pt}}")
Note that the character \ must be described as \\ in
Emacs-Lisp. The next example reads the tabular format from keyboard.
(defun YaTeX:tabular ()
(concat "{" (read-string "Rule: ") "}"))
This section describes how to define the add-in function for
\newcommand.
The first argument of \newcommand begins always with \.
The second argument is usually so complex that we can not edit them in the
minibuffer. Here is the created function considering this.
(defun YaTeX::newcommand (n) ;n is argument position
(cond
((= n 1) ;1st argument is macro name
(read-string "Command: " "\\")) ;initial input `\'
((= n 2) "") ;do nothing when reading arg#2
(t nil)))
Note that when the `argument add-in' function return `nil', normal argument reader will be called.
This section describes how to define the add-in function for
text enclosed by \frac{}.
When enclosing the text 5/3 by \frac{}, you might want to
replace / with }{. Enclosing function
YaTeX::frac-region is called with two arguments, beginning of
enclosed text and end of enclosed text. The function is expected to
replace / with }{. Here is an example expression.
(defun YaTeX::frac-region (beg end)
(catch 'done
(while (search-forward "/" end t)
(goto-char (match-beginning 0))
(if (y-or-n-p "Replace this slash(/) with `}{'")
(throw 'done (replace-match "}{")))
(goto-char (match-end 0)))))
YaTeX calls the add-in functions for specified begin-type, section-type,
and maketitle-type command, if any. `Option add-in' functions for
begin-type are called when \begin{ENV} has been inserted,
functions for section-type are called just before input of the first
argument, and functions for maketitle-type is called after maketitle-type
command has been inserted. `Argument add-in' functions are called at each
entry of arguments for section-type commands.
Many add-in functions for typical LaTeX commands are defined in `yatexadd.el'. Those are also useful as references. Here are the short descriptions on useful functions, where [F] means function, [A] means arguments, [D] means description.
(YaTeX:read-position "htbp")
Dimension, X,
Y respectively.
YaTeX-current-completion-type holds the symbol
according to the current completion type.
If you make your own pretty function and you let it be in public, please send me the function. I'm going to include it in the next release.
First, don't forget to read the section of add-in functions section Add-in functions. If you easily understand how to define them, there's no need to read this section. But being not familiar with Emacs-Lisp, when you don't have clear idea what to do, this section describes how to get YaTeX make add-in function.
There are two methods of generation. One is for fully interactive generator for beginners and another requires little knowledge of Emacs-Lisp.
The former generator is called by M-x YaTeX-generate
strokes. All you have to do is follow the guidances. Defying them may cases the disaster (I wonder what is it???). So when you make some mistake, it is recommendable to type C-g and start afresh.
The latter generator is invoked by the next sequence.
M-x YaTeX-generate-simple
This generator can make both "option add-in" and "argument add-in"
(refer the section add-in functions
section How the add-in function works), whereas YaTeX-generate
cannot make "argument addin".
For example, assume you have the LaTeX command as follows.
\epsinput[t](250,50){hoge.eps}{plain}{Picture of foo}
(A) (B) (1) (2) (3)
(A)Optional parameter to specify the position
One of t(top), b(bottom), l(left), r(right)
(B)Maximum size of frame
(1)1st argument is filename of EPS file
(2)2nd argument indicates
plain do nothing
frame make frame around image
dframe make double-frame around image
for included EPS file.
(3)Caption for the picture
Now get start with generation. Typing M-x YaTeX-generate-simple brings the prompt:
(O)ption? (A)rgument?
Since (A), (B) above are optional argument, all we have to do to complete them is define the option add-in for them. Let's generate the function to complete (A).
M-x YaTeX-generate-simple RET
epsinput RET
o
Typing as above leads the next prompt.
Read type(1): (S)tring (C)omplete (F)ile ([)option (P)osition co(O)rd. (q)uit
This asks that "Which type is the completion style of 1st argument?". Here are the possible completion style.
String
Complete
File
Option
Position
Coord.
Quit
Since (A) is the optional argument to specify the location of included
EPS file, the completion style is Position, and the possible
characters are t, b, l, and r. To tell these information to generator,
operate as follows.
Read type(1).... p
Acceptable characters: tblr RET
(B) is coordinate. So its completion style is coOrd. We want a prompt meaning "Maximum size" when completion.
Read type(2).... o
Prompt for coordinates: Max size RET
That's all for optional argument. Select quit.
Read type(3).... q
Then the generated option add-in function for \epsinput will be shown in the next window.
Next, create the argument add-in. The arguments for \epsinput are EPS file name, framing style, and caption string in sequence.
M-x YaTeX-generate-simple RET
epsinput RET
a
Above key strokes bring the prompt that asks the number of argument. Answer it with 3.
How many arguments?: 3 RET
Then the generator asks the completion style and prompt for completion. Answer them. f for FileName and prompt string.
Read type(1).... f
Prompt for argument#1 EPS file name RET
The second argument is one of selected symbol. So the completion type
is Completion.
Read type(2).... c
Prompt for argument#2 Include style RET
Then all the candidates ready to be read. Type single RET after entering all.
Item[1](RET to exit): plain RET Item[2](RET to exit): frame RET Item[3](RET to exit): dframe RET Item[4](RET to exit): RET
The following prompt asks whether the entered string must belong to
candidates or not. In this case, since the argument must be one of
plain, frame, and dframe, type y.
Require match? (y or n) y
The last argument is the caption string for which any completion is needed.
Read type(3).... s
Prompt for argument#3 Caption RET
default: Figure of RET
Finally we'll get the argument add-in in the next window.
If you get your own pretty function and you let it be in public, please steel yourself in the happy atmosphere and do not send me the function. I do know it is not fine because it is generated by yatexgen:-p.
The standard completion tables provided in `yatex.el' contain a few LaTeX commands I frequently use. This is to lessen the key strokes to complete entire word, because too many candidates rarely used often cause too many hits. Therefore always try to use completion in order to enrich your dictionary, and you will also find `Wild Bird' growing suitable for your LaTeX style.
The package name `Wild Bird' is the English translation of Japanese title `Yachou', which is a trick on words of Japanese.
This program is distributed as a free software. You can use/copy/modify/redistribute this software freely but with NO warranty to anything as a result of using this software. Adopting code from this program is also free. But I would not do contract act.
This software can be treated with: "The 2-Clause BSD License" (since 2017-09-09, yatex 1.80).
Any reports and suggestions are welcome as long as I feel interests in this software. My possible e-mail address is `yuuji@yatex.org'. (as of Sep.2017) And there is mailing list for YaTeX. Although the common language is Japanese, questions in English will be welcome. To join the ML, send the mail whose subject is `append' to the address `yatex@yatex.org. If you have some question, please ask to `yatex-admin@yatex.org'.
The specification of this software will be surely modified (depending on my feelings) without notice :-p.
HIROSE Yuuji
This document was generated on 10 September 2017 using the texi2html translator version 1.52.