yatex: docs/yatexe comparison

comparison docs/yatexe @ 123:590fc51462c7 dev

New typeset menu `latex+p(D)f' added. Call dvipdfmx when typesetting succeeded.

author	yuuji@gentei.org
date	Thu, 27 May 2010 10:16:56 +0900
parents	680d92784c1a
children	6d682b9d4bc8

comparison

equal deleted inserted replaced

-:57d3d9abd661
+:590fc51462c7
 Info file: yatexe,    -*-Text-*-
 produced by `texinfo-format-buffer'
 from file `yatexe.tex'
-using `texinfmt.el' version 2.32 of 19 November 1993.
+using `texinfmt.el' version 2.42 of  7 Jul 2006.
 File: yatexe, Node: Top, Next: What is YaTeX?, Prev: (dir), Up: (dir)
 * Menu:
 * What is YaTeX?::
 * Main features::               What YaTeX can do
 * Installation::                Guide to install
 * Typesetting::                 Call typesetting processes
 * %#notation::                  Meta-keyword `%#'
 * Completion::                  Input LaTeX commands with completion
 * Customizations::              How to breed `Wild Bird'
 * Etcetera::                    YaTeX is acquisitive.
 * Copying::                     Redistribution
 File: yatexe, Node: What is YaTeX?, Next: Main features, Prev: Top, Up: Top
 What is YaTeX?
 **************
 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.
 File: yatexe, Node: Main features, Next: Installation, Prev: What is YaTeX?, Up: Top
 Main features
 * Invocation of typesetter,  previewer and related programs(`C-c t')
 * Typesetting on static region which is independent from point
 * Semiautomatic replacing of `\includeonly'
 * Jumping to error line(`C-c '')
 * Completing-read of LaTeX commands such as `\begin{}',
 `\section' etc.
 (`C-c b', `C-c s', `C-c l', `C-c m')
 * Enclosing text into LaTeX environments or commands
 (`C-u' ABOVEKEYSTROKES)
 * Displaying the structure of text at entering sectioning commands
 * Lump shifting of sectioning commands (*Note view-sectioning::)
 * Adding automatically \usepackage corresponding to inputting LaTeX
 macro with completion
 * Allow you to forget creating \label{}s, \ref or \cite completion
 automatically generate labels.
 File: yatexe, Node: Installation, Next: Typesetting, Prev: Main features, Up: Top
 Installation
 ************
 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".
 File: yatexe, Node: Typesetting, Next: %#notation, Prev: Installation, Up: Top
 `[prefix] t s'
 ... search current string on xdvi-remote
 * Menu:
 * Calling typesetter::
 * Calling previewer::
 * Printing out::
 File: yatexe, Node: Calling typesetter, Next: Calling previewer, Prev: Typesetting, Up: Typesetting
 Calling typesetter
 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.
 File: yatexe, Node: Calling previewer, Next: Printing out, Prev: Calling typesetter, Up: Typesetting
 Calling previewer
 =================
 `[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.
 File: yatexe, Node: Printing out, Prev: Calling previewer, Up: Typesetting
 Printing out
 ============
 by default.  You can skip this by invoking it with universal-argument as
 follows:
 C-u [prefix] tl
 File: yatexe, Node: %#notation, Next: Completion, Prev: Typesetting, Up: Top
 %# notation
 ***********
 You can control the typesetting process by describing `%#' notations in
 the source text.
 * Menu:
 * Changing typesetter::
 * Splitting input files::
 * Static region for typesetting::
 * Lpr format::
 * Editing %# notation::
 File: yatexe, Node: Changing typesetter, Next: Splitting input files, Prev: %#notation, Up: %#notation
 To change the `latex' command or to split a source text.
 To change the typesetting command, write
 %#!latex-big
 anywhere in the source text.  This is useful for changing typesetter.
 File: yatexe, Node: Splitting input files, Next: Static region for typesetting, Prev: Changing typesetter, Up: %#notation
 Splitting input files
 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 *Note Cursor jump::), take described below into consideration.
-* You can put split texts in sub directory, but not in
+* You can put split texts in sub directory, but not in sub directory of
-sub directory of sub directory.
+sub directory.
 * In the main text, specify the child file name with relative path name
-such as \include{chap1/sub}, when you include the file in
+such as \include{chap1/sub}, when you include the file in a
-a sub-directory.
+sub-directory.
-* In a sub-text, write `%#!latex main.tex' even if `main.tex'
+* In a sub-text, write `%#!latex main.tex' even if `main.tex' is in the
-is in the parent directory(not %#!latex ../main.tex).
+parent directory(not %#!latex ../main.tex).
 File: yatexe, Node: Static region for typesetting, Next: Lpr format, Prev: Splitting input files, Up: %#notation
 Static 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.
 File: yatexe, Node: Lpr format, Next: Editing %# notation, Prev: Static region for typesetting, Up: %#notation
 Lpr format
 And if you want YaTeX not to ask you the range of printing out, the next
 example may be helpful.
 %#LPR dvi2ps %s | lpr
 File: yatexe, Node: Editing %# notation, Prev: Lpr format, Up: %#notation
 Editing %# notation
 ===================
 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.
 File: yatexe, Node: Completion, Next: Local dictionaries, Prev: %#notation, Up: Top
 Completion
 **********
 YaTeX makes it easy to input the LaTeX commands.  There are several
 kinds of completion type, begin-type, section-type, large-type, etc...
 * Menu:
 * Begin-type completion::
 * Section-type completion::
 * Large-type completion::
 * Maketitle-type completion::
 * Arbitrary completion::
 * End completion::
 * Accent completion::
 * Image completion::
 * Greek letters completion::
 File: yatexe, Node: Begin-type completion, Next: Section-type completion, Prev: Completion, Up: Completion
 Begin-type completion
 =====================
 "Begin-type completion" completes commands of `\begin{env}' ...
 `\end{env}'.  All of the begin-type completions begin with this key
 sequence.
 `[prefix] b'
 ... start begin-type completion
 `[prefix] b SPACE'
 ... begin-type completion
 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
 This enclosing holds good for the completing input by `[prefix] b SPC'.
 `[prefix] B SPC' enclose a region with the environment selected by
 completing-read.
 File: yatexe, Node: Section-type completion, Next: Large-type completion, Prev: Begin-type completion, Up: Completion
 Section-type completion
 =======================
 \section{Hello world.}
 in your LaTeX source.  When you neglect argument such as
 (C-v for view) \???{} (default section): vspace*
 \vspace*{???}:
 YaTeX puts
 \vspace*{}
 efficiently read with the recursive completion by typing YaTeX's
 completion key sequence in the minibuffer.
 * Menu:
 * view-sectioning::
 File: yatexe, Node: view-sectioning, Prev: Section-type completion, Up: Section-type completion
 view-sectioning
 You can generate this listing buffer (`*Sectioning Lines*' buffer) by
 typing
 `M-x YaTeX-section-overview'
 ... Generate *Sectioning Lines* buffer
-from the LaTeX source buffer.  In this listing buffer, typing `u' on the
+from the LaTeX source buffer.  In this listing buffer, typing `u' on
-sectioning command shifts up the corresponding sectioning command in
+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
+buffer, typing `U' shifts up all sectioning commands in the region,
-`U' shifts down.  Here are all the key bindings of `*Sectioning Lines*'
+and `U' shifts down.  Here are all the key bindings of
-buffer.
+`*Sectioning Lines*' buffer.
 `SPC'
 ... Jump to corresponding source line
 `.'
 ... Display corresponding source line
 ... Shift down sectioning lines in region
 `0...6'
 ... Hide sectioning commands whose level is lower than n
 File: yatexe, Node: Large-type completion, Next: Maketitle-type completion, Prev: Section-type completion, Up: Completion
 Large-type completion
 =====================
 `[prefix] l'
 ... large-type completion
 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 changing the letter after
 prefix key stroke as `[prefix] L'.  It encloses the region by braces with
 large-type command.
 File: yatexe, Node: Maketitle-type completion, Next: Arbitrary completion, Prev: Large-type completion, Up: Completion
 Maketitle-type completion
 =========================
 begins maketitle-completion.  Above mentioned method is true for
 maketitle-completion, and there are LaTeX commands with no arguments in
 completion table.
 File: yatexe, Node: Arbitrary completion, Next: End completion, Prev: Maketitle-type completion, Up: Completion
 Arbitrary completion
 ====================
 `[prefix] SPC'
 ... arbitrary completion
 after the initial string of LaTeX command that is preceded by `\'.
 File: yatexe, Node: End completion, Next: Accent completion, Prev: Arbitrary completion, Up: Completion
 End completion
 ==============
 YaTeX automatically detects the opened environment and close it with
-\`\end{environment}'.  Though proficient YaTeX users never fail to make
+`\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
 `[prefix] e'
 ... `end' completion
 at the end of the opened environment.
 File: yatexe, Node: Accent completion, Next: Image completion, Prev: End completion, Up: Completion
 Accent completion
 =================
 character `o' for example, then
 \`{o}
 will be completed, and the cursor gets out from braces.
 File: yatexe, Node: Image completion, Next: Greek letters completion, Prev: Accent completion, Up: Completion
 Image completion of mathematical sign
 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
+Considering such image, you can write `\leftarrow' by typing `<-'
-`;' (semicolon) as a prefix.  In the same way, `\longleftarrow' (`<--') is
+after `;' (semicolon) as a prefix.  In the same way,
-completed by typing `;<--', infinity mark which is imitated by `oo' is
+`\longleftarrow' (`<--') is completed by typing `;<--',
-completed by typing `;oo'.
+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'
 ; 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
+`;' itself in math-environment is inserted by `;;'.  Typing
-midst of image completion shows all of the LaTeX commands that start with
+`TAB' in the midst of image completion shows all of the LaTeX
-the same name as string you previously typed in.  In this menu buffer,
+commands that start with the same name as string you previously typed in.
-press `RET' after moving the cursor (by `n', `p', `b', `f') to insert the
+In this menu buffer, press `RET' after moving the cursor (by `n',
-LaTeX command.
+`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.
 File: yatexe, Node: Greek letters completion, Prev: Image completion, Up: Completion
 Greek letters completion
 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
+If you will find `;' or `:' doesn't work in correct position of
-environment, it may be a bug of YaTeX.  Please send me a bug report with
+math environment, it may be a bug of YaTeX.  Please send me a bug report
-the configuration of your text, and avoid it temporarily by typing `;' or
+with the configuration of your text, and avoid it temporarily by typing
-`:' after universal-argument(`C-u') which forces `;' and `:' to work as
+`;' or `:' after universal-argument(`C-u') which forces
-math-prefix.
+`;' and `:' to work as math-prefix.
 File: yatexe, Node: Local dictionaries, Next: Commenting out, Prev: Completion, Up: Top
 Local dictionaries
 If you find this switching feature meaningless and bothersome, put the
 next expression into your `~/.emacs'
 (setq YaTeX-nervous nil)
 File: yatexe, Node: Commenting out, Next: Cursor jump, Prev: Local dictionaries, Up: Top
 Commenting out
 **************
 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
+You can also comment out an environment between `\begin' and
-a `\begin'-\`\end' pair themselves, by making the following key strokes on
+`\end', or a `\begin'-\`\end' pair themselves, by making the
-the line where `\begin{}' or `\end{}' exists.
+following key strokes on the line where `\begin{}' or
+`\end{}' exists.
 `[prefix] >'
 ... comment out from \begin to \`end'
 `[prefix] <'
 ... uncomment from \begin to \`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.
 File: yatexe, Node: Cursor jump, Next: Changing and Deleting, Prev: Commenting out, Up: Top
 Cursor jump
 ***********
 * Menu:
 * Jump to corresponding object::
 * Invoking image processor::
 * Jump to main file::
 * Jumping around the environment::
 * Jumping to last completion position::
 File: yatexe, Node: Jump to corresponding object, Next: Invoking image processor, Prev: Cursor jump, Up: Cursor jump
 Jump to corresponding object
 the main text, YaTeX switches buffer to `chap1.tex'.
 `[prefix] 4 g'
 ... go to corresponding object in other window
-do the same job as `[prefix] g' except it's done in other window.  Note
+do the same job as `[prefix] g' except it's done in other window.
-that this function doesn't work on `begin/end', `%#BEGIN/%#END' pairs
+Note that this function doesn't work on `begin/end',
-because it is meaningless.
+`%#BEGIN/%#END' pairs because it is meaningless.
 File: yatexe, Node: Invoking image processor, Next: Jump to main file, Prev: Jump to corresponding object, Up: Cursor jump
 Invoking image processor
 3. If not, check the existence of each file which is supplied the
 extension in the cdr part of each list of
 `YaTeX-file-processor-alist'.  If any, call the corresponding image
 viewer or drawing tool.
 File: yatexe, Node: Jump to main file, Next: Jumping around the environment, Prev: Invoking image processor, Up: Cursor jump
 Jump to main file
 =================
 `[prefix] ^'
 ... visit main file
 `[prefix] 4^'
 ... visit main file in other buffer
-in a sub text switch the buffer to the main text specified by `%#!'
+in a sub text switch the buffer to the main text specified by
-notation.
+`%#!'  notation.
 File: yatexe, Node: Jumping around the environment, Next: Jumping to last completion position, Prev: Jump to main file, Up: Cursor jump
 Jumping around the environment
 `M-C-e'
 ... `end' of environment
 `M-C-@'
 ... mark environment
 File: yatexe, Node: Jumping to last completion position, Prev: Jumping around the environment, Up: Cursor jump
 Jumping to last completion position
 ===================================
 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).
 File: yatexe, Node: Changing and Deleting, Next: Filling, Prev: Cursor jump, Up: Top
 Changing and Deleting
 *********************
 `[prefix] k'
 ... kill LaTeX command
 * Menu:
 * Changing LaTeX commands::
 * Killing LaTeX commands::
 File: yatexe, Node: Changing LaTeX commands, Next: Killing LaTeX commands, Prev: Changing and Deleting, Up: Changing and Deleting
 Changing LaTeX commands
 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.
 File: yatexe, Node: Killing LaTeX commands, Prev: Changing LaTeX commands, Up: Changing and Deleting
 Killing LaTeX commands
 ======================
 Original text:                  [prefix] k      C-u [prefix] k
 Main \footnote{note} here.    Main note here. Main  here.
 ~(cursor)
 File: yatexe, Node: Filling, Next: Updation of includeonly, Prev: Changing and Deleting, Up: Top
 Filling
 *******
 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
+in your `~/.emacs'.  If you are not familiar with regular expression
-Emacs-Lisp, name a newcommand for `itemize' beginning with `\item' such as
+for Emacs-Lisp, name  a newcommand  for  `itemize' beginning  with
-`\itembf', not `\bfitem'.
+`\item' such as `\itembf', not `\bfitem'.
 This function reformats the `\item' into `hang-indented' style.  For
 example:
 itemize, enumerate environment:
 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.
 File: yatexe, Node: Updation of includeonly, Next: What column, Prev: Filling, Up: Top
 Updation of `\includeonly'
 **************************
 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
+in the minibuffer.  Type `a' if you want to add the current file name
-`\includeonly' list, `r' to replace \`includeonly' list with the current
+to `\includeonly' list, `r' to replace \`includeonly' list
-file, and type `%' to comment out the `\includeonly' line.
+with the current file, and type `%' to comment out the
+`\includeonly' line.
 File: yatexe, Node: What column, Next: Intelligent newline, Prev: Updation of includeonly, Up: Top
 What column?
 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 `%'.
 File: yatexe, Node: Intelligent newline, Next: Usepackage checker, Prev: What column, Up: Top
 Intelligent newline
 *******************
 and `\hline' if other `\hline' is found in backward.  Here are the list of
 contents vs. environments.
 * `tabular', `tabular*', `array'
-Corresponding number of `&' and `\\'.
+Corresponding number of `&' and `\\'.  And `\hline' if
-And `\hline' if needed.
+needed.
 * `tabbing'
 The same number of `\>' as `\=' in the first line.
 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
+`YaTeX-intelligent-newline-foo' to insert corresponding contents.
-function will be called at the beginning of the next line after the
+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.
 File: yatexe, Node: Usepackage checker, Next: Online help, Prev: Intelligent newline, Up: Top
 Usepackage checker
 ******************
 `\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.
 File: yatexe, Node: Online help, Next: Browsing file hierarchy, Prev: Usepackage checker, Up: Top
 Online help
 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.
 File: yatexe, Node: Browsing file hierarchy, Next: Cooperation with other packages, Prev: Online help, Up: Top
 Browsing file hierarchy
 ... quit
 Note that operations on the file contents in the next window do not work
 correctly when you close the corresponding file.
 File: yatexe, Node: Cooperation with other packages, Next: Customizations, Prev: Browsing file hierarchy, Up: Top
 Cooperation with other packages
 *******************************
 `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.
 File: yatexe, Node: Customizations, Next: Etcetera, Prev: Cooperation with other packages, Up: Top
 Customizations
 **************
 You can customize YaTeX by setting Emacs-Lisp variables and by making
 add-in functions.
 * Menu:
 * Lisp variables::
 * Add-in functions::
 * Add-in generator::
 File: yatexe, Node: Lisp variables, Next: Add-in functions, Prev: Customizations, Up: Customizations
 Lisp variables
 invoked with `C-c Capital-letter' remain valid, if you want to disable
 those bindings, set that variable to 1 instead of `t').
 * Menu:
 * All customizable variables::
 * Sample definitions::
 * Hook variables::
 * Hook file::
 File: yatexe, Node: All customizable variables, Next: Sample definitions, Prev: Lisp variables, Up: Lisp variables
 All customizable variables
 Set this nil to produce all messages in English (`Depends on Japanese
 feature of Emacs')
 -- Variable: YaTeX-kanji-code
 Default buffer-file-coding-system for YaTeX modes' buffer.  Set this
-0 to no language conversion.  Nil to preserve original coding-system.
+0 to no language conversion.  Nil to preserve original
-(`1 or 2')
+coding-system. 1=Shift JIS, 2=JIS, 3=EUC, 4=UTF-8 (`1 or 2')
 -- Variable: YaTeX-prefix
 Prefix key stroke (`C-c')
 -- Variable: YaTeX-inhibit-prefix-letter
 -- Variable: YaTeX-fill-prefix
 Fill-prefix used in yatex-mode (`nil')
 -- Variable: YaTeX-user-completion-table
 Name of user dictionary where learned completion table will be
-stored. (`"~/.yatexrc"')
+stored.  (`"~/.yatexrc"')
 -- Variable: tex-command
 LaTeX typesetter command (`"latex"')
 -- Variable: dvi2-command
 Regexp of LaTeX sectioning command
 (`"\\(part\\|chapter\\*?\\|\\(sub\\)*\\(section\\|paragraph\\)\\*?\\)\\b"')
 -- Variable: YaTeX-fill-inhibit-environments
 Inhibit fill in these environments (`'("tabular" "tabular*" "array"
-"picture" "eqnarray" "eqnarray*" "equation" "math" "displaymath"
+picture" "eqnarray" "eqnarray*" "equation" "math" "displaymath"
-"verbatim" "verbatim*")')
+verbatim" "verbatim*")')
 -- Variable: YaTeX-uncomment-once
 T for deleting all preceding `%' (`nil')
 -- Variable: YaTeX-close-paren-always
 -- Variable: YaTeX-hierarchy-ignore-heading-regexp
 `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
 -*'.
 -- Variable: YaTeX-skip-default-reader
 Non-nil for this variable skips the default argument reader of
 section-type command when add-in function for it is not defined
 YaTeX tries to search italic, bold fontsets or not (`t' if Emacs-20
 or later).  This variable is effective only when font-lock is used.
 (`(featurep 'hilit19)'
 -- Variable: YaTeX-singlecmd-suffix
-Suffix which is always inserted after maketitle-type macros.  `"{}"'
+Suffix which is always inserted after maketitle-type macros.
-is recommended.
+`"{}"' is recommended.
 -- Variable: YaTeX-package-alist-private
 Alist of LaTeX2e-package name vs. lists of macros in it.  Set this
 alist properly and YaTeX automatically check the declaratiion of
 `usepackage' for corresponding macro, when you input that macro with
 completion.  If required `usepackage' is not found, YaTeX also
 automatically inserts `\usepackage'.  Alist is as follows;
-'((PackageName1
+'((PackageName1 (completionType ListOfMacro) (completionType
-(completionType ListOfMacro)
+ListOfMacro)) (PackageName2 (completionType ListOfMacro)
-(completionType ListOfMacro))
+(completionType ListOfMacro...))....)  completionType is one of `env,
-(PackageName2
+section, maketitle'.  Consult the value of
-(completionType ListOfMacro)
-(completionType ListOfMacro...))....)  completionType is
-one of `env, section, maketitle'.  Consult the value of
 `YaTeX-package-alist-default' as an example.
 -- Variable: YaTeX-tabular-indentation
 At indentation by `C-i' in tabular or array environment, YaTeX put
 the additional spaces to the normail indentation depth.  The number
 (if (setq command (cdr (assoc command alist)))
 (concat command ":" value)
 (YaTeX::ref-generate-label nil nil))))
 File: yatexe, Node: Sample definitions, Next: Hook variables, Prev: All customizable variables, Up: Lisp variables
 Sample definitions
 ------------------
 character, add the following `setq' to `~/.emacs'.
 (setq YaTeX-prefix "\e"
 YaTeX-user-completion-table "~/src/emacs/yatexrc"
 YaTeX-fill-prefix "       ")
 File: yatexe, Node: Hook variables, Next: Hook file, Prev: Sample definitions, Up: Lisp variables
 Hook variables
 '(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.
 File: yatexe, Node: Hook file, Prev: Hook variables, Up: Lisp variables
 Hook file
 ---------
 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.
 File: yatexe, Node: Add-in functions, Next: Add-in generator, Prev: Lisp variables, Up: Customizations
 Add-in functions
 ================
 1. Define the function
 2. Put the function into `yatexhks.el'
 * Menu:
 * How the add-in function works::
 * How the function is called::
 * Useful functions for creating add-in::
 * Contribution::
 File: yatexe, Node: How the add-in function works, Next: How the function is called, Prev: Add-in functions, Up: Add-in functions
 How the add-in function works
 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
+Normally, the expression `a/c' is translated to
-enclosing add-in is useful for modifying `/' to `}{'.
+`\frac{a}{c}'. An enclosing add-in is useful for modifying
+`/' to `}{'.
 * Menu:
 * Defining option-add-in::
 * Defining argument-add-in::
 * Defining enclosing-add-in::
 File: yatexe, Node: Defining option-add-in, Next: Defining argument-add-in, Prev: How the add-in function works, Up: How the add-in function works
 Defining `option add-in'
 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: ") "}"))
 File: yatexe, Node: Defining argument-add-in, Next: Defining enclosing-add-in, Prev: Defining option-add-in, Up: How the add-in function works
 Defining `argument add-in'
 ..........................
 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.
 File: yatexe, Node: Defining enclosing-add-in, Prev: Defining argument-add-in, Up: How the add-in function works
 Defining `enclosing add-in'
 (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 "}{")))
+(throw 'done (replace-match "}{")))
 (goto-char (match-end 0)))))
 File: yatexe, Node: How the function is called, Next: Useful functions for creating add-in, Prev: How the add-in function works, Up: Add-in functions
 How the function is called
 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.
 File: yatexe, Node: Useful functions for creating add-in, Next: Contribution, Prev: How the function is called, Up: Add-in functions
 Useful functions for creating add-in
 ------------------------------------
 `[F]'
 YaTeX:read-position
 `[A]'
 Character list which can show up in the brackets
 `[D]'
-Return the location specifier such as `[htb]'.  When nothing is
+Return the location specifier such as `[htb]'.  When
-entered, omit [] itself.  If the possible characters are "htbp", call
+nothing is entered, omit [] itself.  If the possible characters
-this function as `(YaTeX:read-position "htbp")'
+are "htbp", call this function as
+`(YaTeX:read-position "htbp")'
 `[F]'
 YaTeX:read-coordinates
 `[A]'
 Base prompt, X-axis prompt, Y-axis prompt (each optional)
 `[D]'
 Read the coordinates with the prompt "BasePrompt X-axisPrompt:" for
-X-axis, "BasePrompt Y-axisPrompt:" for Y-axis, and return it in the
+X-axis, "BasePrompt Y-axisPrompt:" for Y-axis, and return it in the form
-form of "(X,Y)".  The default prompts are `Dimension', `X', `Y'
+of "(X,Y)".  The default prompts are `Dimension', `X',
-respectively.
+`Y' respectively.
 `[F]'
 YaTeX:check-completion-type
 `[A]'
 One of the symbols: 'begin, 'section, or 'maketitle
 `[D]'
 Check the current completion type is specified one and cause error
 if not. The variable `YaTeX-current-completion-type' holds the symbol
 according to the current completion type.
 File: yatexe, Node: Contribution, Prev: Useful functions for creating add-in, Up: Add-in functions
 Contribution
 ------------
 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.
 File: yatexe, Node: Add-in generator, Prev: Add-in functions, Up: Customizations
 Add-in generator
 Simple generator
 ----------------
-The latter generator is invoked by the next sequence.
+The latter generator is invoked by the next sequence.  `M-x
-`M-x YaTeX-generate-simple'
+YaTeX-generate-simple' This generator can make both "option add-in" and
-This generator can make both "option add-in" and "argument add-in"
+argument add-in" (*refer the section add-in functions* *Note How the
-(*refer the section add-in functions*
+add-in function works::), whereas `YaTeX-generate' cannot make "argument
-*Note How the add-in function works::), whereas `YaTeX-generate'
+addin".
-cannot make "argument addin".
 For example, assume you have the LaTeX command as follows.
-	\epsinput[t](250,50){hoge.eps}{plain}{Picture of foo}
+\epsinput[t](250,50){hoge.eps}{plain}{Picture of foo}
-	         (A)  (B)     (1)      (2)      (3)
+(A)  (B)     (1)      (2)      (3)
-	(A)Optional parameter to specify the position
+(A)Optional parameter to specify the position
-	   One of t(top), b(bottom), l(left), r(right)
+One of t(top), b(bottom), l(left), r(right)
-	(B)Maximum size of frame
+(B)Maximum size of frame
-	(1)1st argument is filename of EPS file
+(1)1st argument is filename of EPS file
-	(2)2nd argument indicates
+(2)2nd argument indicates
-		plain		do nothing
+plain		do nothing
-		frame		make frame around image
+frame		make frame around image
-		dframe		make double-frame around image
+dframe		make double-frame around image
-	   for included EPS file.
+for included EPS file.
-	(3)Caption for the picture
+(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) 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
+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.
 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[1](RET to exit):		plain RET
-		Item[2](RET to exit):		frame RET
+Item[2](RET to exit):		frame RET
-		Item[3](RET to exit):		dframe RET
+Item[3](RET to exit):		dframe RET
-		Item[4](RET to exit):		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'.
 ------------
 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.
 File: yatexe, Node: Etcetera, Next: Copying, Prev: Customizations, Up: Top
 Etcetera
 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.
 File: yatexe, Node: Copying, Prev: Etcetera, Up: Top
 Copying
 HIROSE Yuuji
 Tag table:
-Node: Top153
+Node: Top145
-Node: What is YaTeX?1493
+Node: What is YaTeX?1472
-Node: Main features1865
+Node: Main features1845
-Node: Installation3456
+Node: Installation3436
-Node: Typesetting4232
+Node: Typesetting4213
-Node: Calling typesetter5061
+Node: Calling typesetter5006
-Node: Calling previewer6406
+Node: Calling previewer6352
-Node: Printing out6766
+Node: Printing out6713
-Node: %#notation7057
+Node: %#notation7005
-Node: Changing typesetter7432
+Node: Changing typesetter7336
-Node: Splitting input files7795
+Node: Splitting input files7700
-Node: Static region for typesetting9222
+Node: Static region for typesetting9124
-Node: Lpr format10350
+Node: Lpr format10253
-Node: Editing %# notation11406
+Node: Editing %# notation11310
-Node: Completion11924
+Node: Completion11829
-Node: Begin-type completion12483
+Node: Begin-type completion12318
-Node: Section-type completion15526
+Node: Section-type completion15360
-Node: view-sectioning17960
+Node: view-sectioning17781
-Node: Large-type completion19539
+Node: Large-type completion19361
-Node: Maketitle-type completion20269
+Node: Maketitle-type completion20091
-Node: Arbitrary completion20820
+Node: Arbitrary completion20643
-Node: End completion21209
+Node: End completion21033
-Node: Accent completion21678
+Node: Accent completion21502
-Node: Image completion22294
+Node: Image completion22119
-Node: Greek letters completion24550
+Node: Greek letters completion24374
-Node: Local dictionaries25276
+Node: Local dictionaries25101
-Node: Commenting out26212
+Node: Commenting out26038
-Node: Cursor jump27670
+Node: Cursor jump27497
-Node: Jump to corresponding object27981
+Node: Jump to corresponding object27788
-Node: Invoking image processor29381
+Node: Invoking image processor29188
-Node: Jump to main file30723
+Node: Jump to main file30531
-Node: Jumping around the environment31087
+Node: Jumping around the environment30897
-Node: Jumping to last completion position31504
+Node: Jumping to last completion position31315
-Node: Changing and Deleting32012
+Node: Changing and Deleting31824
-Node: Changing LaTeX commands32403
+Node: Changing LaTeX commands32205
-Node: Killing LaTeX commands33579
+Node: Killing LaTeX commands33382
-Node: Filling34763
+Node: Filling34567
-Node: Updation of includeonly36613
+Node: Updation of includeonly36422
-Node: What column37409
+Node: What column37219
-Node: Intelligent newline38493
+Node: Intelligent newline38304
-Node: Usepackage checker40153
+Node: Usepackage checker39957
-Node: Online help40743
+Node: Online help40548
-Node: Browsing file hierarchy42417
+Node: Browsing file hierarchy42223
-Node: Cooperation with other packages44153
+Node: Cooperation with other packages43960
-Node: Customizations44857
+Node: Customizations44665
-Node: Lisp variables45190
+Node: Lisp variables44961
-Node: All customizable variables46193
+Node: All customizable variables45920
-Node: Sample definitions55941
+Node: Sample definitions55615
-Node: Hook variables56453
+Node: Hook variables56128
-Node: Hook file57156
+Node: Hook file56832
-Node: Add-in functions57494
+Node: Add-in functions57171
-Node: How the add-in function works58353
+Node: How the add-in function works58009
-Node: Defining option-add-in60551
+Node: Defining option-add-in60195
-Node: Defining argument-add-in61272
+Node: Defining argument-add-in60917
-Node: Defining enclosing-add-in62153
+Node: Defining enclosing-add-in61798
-Node: How the function is called63006
+Node: How the function is called62654
-Node: Useful functions for creating add-in63681
+Node: Useful functions for creating add-in63330
-Node: Contribution65085
+Node: Contribution64740
-Node: Add-in generator65358
+Node: Add-in generator65014
-Node: Etcetera70751
+Node: Etcetera70474
-Node: Copying71355
+Node: Copying71079
 End tag table

Mercurial > hgrepos > hgweb.cgi > yatex

comparison docs/yatexe @ 123:590fc51462c7 dev