diff options
Diffstat (limited to 'Master/texmf-dist/source/latex3')
31 files changed, 23393 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex3/galley/galley2.dtx b/Master/texmf-dist/source/latex3/galley/galley2.dtx new file mode 100644 index 00000000000..a2fd84c8e16 --- /dev/null +++ b/Master/texmf-dist/source/latex3/galley/galley2.dtx @@ -0,0 +1,3780 @@ +% \iffalse +%% +%% $Header: /usr3/users/latex3/design/consolidation/CURRENT/RCS/galley2.dtx,v 1.15 2000/01/27 21:45:56 latex3 Exp $ +%% +%% (C) Copyright 1999-2000 Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{galley.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{galley2} +%<driver>\ProvidesFile{galley.drv} +% \fi +% \ProvidesFile{galley2.dtx} + [2000/01/27 v0.2s galley structures] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} + \typeout{********} + \typeout{* Unpack with:} + \typeout{* \string\generate{% + \string\file{galley2.sty}{\string\from{galley2.dtx}{package,trace}}} + } + \typeout{********} +% \usepackage{ldcdoc} +% \makeatletter +% \let\GAL@typeout\@gobble \let\GAL@show@datastructure\@gobble +% \makeatother + + \newcommand\LaTeXplus{\LaTeXe$*$} + + \CodelineIndex \EnableCrossrefs + \renewcommand\MakePrivateLetters{\makeatletter\catcode`\:11\relax} + \begin{document} + \DocInput{galley2.dtx} + \end{document} +%</driver> +% \fi +% +% \CheckSum{0} +% +% \newcommand\PARM[1]{parameter \textbf{#1}} +% \newcommand\subsubsubsection{\paragraph} +% +% +% \GetFileInfo{galley2.dtx} +% +% \title{The \textsf{galley} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{FMi} +% \date{\filedate} +% \maketitle +% +% \begin{abstract} +% This module provides the data structure for galleys and contains +% the low-level interfaces for direct manipulation of this data structure. +% Higher-level templates for interfacing with the +% galley mechanism are set up by the module +% \texttt{xhj}. +% The low-level interfaces of the current module are geared +% towards package writers having special needs which are not +% fulfilled by the templates in the \texttt{xhj} module. +% They are not intended to be used directly in class design. +% \end{abstract} +% +% \tableofcontents +% +% \section{Introduction} +% +% In \LaTeXplus{} terminology a galley is a rectangular area which +% receives text and other material filling it from +% top.\footnote{The predominant direction depends on the writing +% system and with extensions to \TeX{} such as Omega there are +% possibilities to define galleys with a different filling direction.} +% The vertically extend of a galley is normally not restricted +% (there are exceptions); instead certain chunks are taken off the top +% of an +% already partially filled galley to form columns or similar areas +% on a page. This process is typically asynchronous but there are ways +% to control or change its behavior. +% +% Examples for galleys are `the main galley', where the continuous +% document data gets formatted into and from which columns and pages are +% constructed, and `vbox galley's, such as the body of a minipage +% environment or the body of a float (in \LaTeXe only---the new float +% mechanism for \LaTeXplus{} will employ horizontally oriented float +% bodies). The latter galleys are typically not being split after +% formatting though there can be exceptions. +% +% The data that is being formatted into a galley can be described as a +% sequence of paragraphs of text separated by vertical material such +% as vertical spaces, penalties, writes, specials, etc. +% +% There are two components that a mechanism for galleys has to provide: +% the framework for manipulating the shape and placement of paragraph +% text (this is provided with higher-level templates in the module +% \texttt{xhj}) and the framework for manipulating the inter-paragraph +% material. +% +% +% +% \subsection{Some problems with \LaTeXe{} galleys} +% +% The handling of inter-paragraph material poses the most difficult +% problems as it is typically influenced by various factors and +% information gained at different stages throughout the document +% processing. \LaTeXe{} provided a certain control over this material, +% e.g., headings would set a |@nobreak| flag to prevent paragraph +% breaking after them and other commands and environments would test +% for it; |\addvspace| and |\addpenalty| could be used several times +% in succession and still provide reasonable results, but all in all +% these have been adhoc solutions to the most pressing problem of that +% area---many others remained unsolved: +% +% The following is a list of document extracts which one can imagine +% to appear in ordinary documents. They all have in common that in +% \LaTeXe{} they produce surprising (and undesired) results: +% \begin{enumerate} +% \item +% \begin{verbatim} +% \end{itemize} \vspace{3pt} \begin{itemize} ... +%\end{verbatim} +% \ldots not three points of extra space but 13 (with +% the \texttt{article} class) +% +% \item +% \begin{verbatim} +% \section{HEAD} {\sc ABC} ... +%\end{verbatim} +% \ldots page breaking restrictions apply to the +% second paragraph after the heading not the first as they +% should +% \item +% \begin{verbatim} +% \usepackage{hyperref} +%\end{verbatim} +% \ldots the danger of completely changed vertical spacing because +% the |\special|s added by \texttt{hyperref} interfere with the +% spacing and penalty mechanisms of \LaTeXe +% +% +% \item +% \begin{verbatim} +% {\section{HEAD}} para text \par \begin{itemize} ... +%\end{verbatim} +% \ldots one gets an indentation after the heading; a page break might +% happen after the first line in the paragraphs; and there will be no +% space above the itemize environment (though there will be space +% below) --- because of this \LaTeXe{} claims this is incorrect input +% --- and then since \LaTeX\,2.09 uses the equivalent of +% |\twocolumn[\chapter{HEAD}]| in certain circumstances in the report +% and book class :-) +% \end{enumerate} +% +% All these pitfalls are due to the fact that \LaTeXe{} typesets the +% inter-paragraph material whenever it receives it and once it is +% typeset \TeX{} has only a limited power to modify the material +% already present on the galley. +% +% Thus to be able to do better one has to defer any typesetting until +% the very last moment (i.e., when the next paragraph starts) and +% instead collect such inter-paragraph material in a suitable data +% structure where it can be manipulated and examined. +% The present code in this module provides such a data structure. Of +% course, to be successful it is important that all functions that +% would normally produce inter-paragraph material (such as user +% commands like |\vspace|) obey the concepts behind the mechanism and +% refrain from directly adding to the galley. +% How this is achieved will be explained in the next sections. +% +% +% \section{The galley data structure} +% +% A galley is a \LaTeX{} object which contains (or receives) +% paragraphs and typesets them vertically below each other intermixed +% with material like vertical spaces and penalties, etc.\ which are +% placed between such paragraphs. +% +% Galleys can be nested and thus data structures associated with them +% need to be provided using a stack structure. +% +% Technical aspects of the implementation of this structure are +% discussed in section~\ref{sec:galley-concept-impl}. +% +% +% \subsection{Writes, marks, specials and inserts} +% +% Writes, marks, specials and inserts are internally represented by +% \TeX{} as invisible objects (nodes) within the horizontal or +% vertical lists of \TeX. The +% problem with this is that they interfere with other nodes, produce +% additional break points, etc. +% +% For this reason they should not appear on their own but need to be +% placed into precisely controlled places. They can either go directly +% after the last line of a paragraph (preceded and followed by +% |\nobreak|) or they can go directly in front of the next +% paragraph. Table~\ref{tab:vthing} lists the different nodes and +% their suggested handling. +% \begin{table} +% \begin{center} +% \begin{tabular}{ll} +% \hline +% vthing & attach to \\ +% \hline +% insert & prev \\ +% write & prev or next (flag) \\ +% mark & prev or next (flag) \\ +% special (hyperref) & prev or next (different command) \\ +% special (others) & next +% \end{tabular} +% \end{center} +% \small ^^A well designed object :-) +% \begin{quote} +% prev := just add to MVL followed by |\nobreak| \\ +% next := store tokens and put in a primitive ``in hmode at start of +% next para'' +% \end{quote} +% \caption{Invisible nodes and their handling}\label{tab:vthing} +% \end{table} +% +% +% \subsection{Individual parameters} +% +% Each parameter related to a galley exists in two incarnation: +% \begin{itemize} +% \item it has one value which is considered to be static for a +% sequence of paragraphs (potentially for all paragraphs typeset on +% this level); any change to it via some mutator command will +% persist until a further change or the end of the level --- called +% static galley parameter value (SGPV) +% \item it has one value which is reset after each use to the +% corresponding static value --- called dynamic galley parameter +% value (DGPV). +% \end{itemize} +% +% The actual processing routines always use the DGPVs. Thus to produce +% a paragraph sequence with a certain uniform setting of parameters +% one would set up (or modify) the SGPVs, and to locally overwrite +% individual values for one paragraph one would modify the relevant DGPVs. +% +% +% \subsubsection{Vertical (pre-paragraph) parameters} +% +% \begin{description} +% \item[nobreak flag (b)] a flag that signals how page breaking should +% be handled +% between the previous and the upcoming paragraph; it takes a number +% between 0 and 3 with the following meaning: 0 means normal +% breaking behavior (value of \PARM{penalty} is used), 1 means +% prevent break between paragraphs (value of \PARM{penalty} is +% discarded and replaced by 10000), 2 is like 1 but additionally +% prevents\footnote{as far as possible with \TeX} a page break +% within the first lines of the upcoming paragraph (by fiddling with +% |\clubpenalty|), 3 is like 1 but also suppresses a page break for +% the whole upcoming paragraph (by setting +% |\interlinepenalty|)\footnote{One can actually implement something +% even better: with e\TeX{} more control is possible and with normal +% \TeX{} one could prevent a break for a minimum of X lines by +% checking on the value of \texttt{\textbackslash prevgraf} and decreasing this for the next +% time around} +% At the moment it also supports negative numbers ($-3$ especially) +% which have the same meaning as the positive counterparts except +% that they only influence the breaking within the paragraph, e.g., +% $-3$ do not break within the next paragraph (which is useful for +% initials etc). However this should probably be redesigned properly! +% \item[vpenalty (p)] penalty between paragraphs unless flag above is set +% \item[vspace (v)] skip between paragraphs as set by class or package +% commands, if -1sp then |\parskip| is used instead.\footnote{This +% -1sp is a speedup measure to avoid the need for an additional flag +% for suppressing or adding \texttt{\textbackslash parskip}, this way +% between normal paragraphs \texttt{\textbackslash parskip} is +% added (as the default for this parameter is -1sp) but any setting +% will result in suppressing it. Of course this means if some +% environment requests some space it does get 1sp less, acceptable? +% Using 0pt instead is not a good idea as it makes it difficult to +% state for some environment that all space should be suppressed.} +% \item[user vpenalty (up)] penalty between paragraphs set by user level +% commands +% \item[user vspace (uv)] additional space between paragraphs set by user level +% commands. This space is always added and never suppressed or subject +% to functions like using the maximum, since it is provided by +% user commands like |\vspace| where we assume that the user intends +% to correct the default result. +% \item[prev whatsits (pw)] whatsits that are supposed to get attached to +% the previous paragraph +% \item[parshape (ps)] structured parameter that sets up a \TeX{} +% |\parshape| declaration or empty; it replaces the next two parameters +% in the current implementation. However for reasons of secure +% programming it might be necessary to have all three. (Right now +% |\linewidth| and |\@totalleftmargin| are locally set when +% modifying the ps parameter and thus are in danger of getting out +% of sync if setting happens not at group boundaries. +% \item[measure (m)] nominal width of the upcoming paragraph lines +% (|\linewidth| is set to this value)\footnote{Not used right now +% see comment on ps parameter.} +% \item[hoffset (h)] offset for the upcoming paragraph lines from the left +% margin (in \LaTeXe{} this was +% |\@totalleftmargin|).\footnote{Not used right now, see comment on +% ps parameter.} +% \end{description} +% +% +% \subsubsection{Paragraph-start parameters} +% +% \begin{description} +% \item[indentation (i)] flag to suppress insertion of indentation +% box. A value of 0 means insert indentation any other value suppresses +% indentation. +% \item[next whatsits (nw)] whatsits that are supposed to get attached to +% the next paragraph +% \item[object (o)] typeset material at the start of the paragraph +% \item[queries (q)] information about previously seen objects/states +% on the galley that can be queried by following code as necessary, +% e.g., the fact that we just have processed an `item', or a +% `heading', or \ldots +% +% This parameter is not yet properly used and perhaps becomes +% obsolete once there is a proper mechanism for handing such data. +% \end{description} +% +% +% \subsubsection{Paragraph-justification parameters} +% +% The following parameter is supposed to define the inner shape of a +% paragraph, e.g., adjusted, centered lines, ragged shapes, etc. It +% is not meant to define the measure (for this see the \PARM{parshape}). +% \begin{description} +% \item[justification (j)] This is a multivalued parameter consisting of +% \begin{itemize} +% \item the counterpart to |\parfillskip| at the +% beginning of a paragraph +% \item the \TeX{} |\leftskip| +% \item the \TeX{} |\rightskip| +% \item the \TeX{} |\parfillskip| +% \item the \TeX{} |\spaceskip| +% \item the \TeX{} |\xspaceskip| +% \item glue specification to be put in front of a forced ``newline'' +% \item the \TeX{} |\parindent|\footnote{This parameter should +% perhaps be taken out, there is some dicussion related to +% this elsewhere.} +% \end{itemize} +% \end{description} +% +% \subsubsection{Line breaking parameters} +% +% Line breaking parameters are considered to be not related to +% individual paragraphs but to paragraphs sequences, i.e., they are +% not reset on each paragraph. Wrong? Instead they are initialized at +% start of galley and are otherwise only settable via templates. One +% could of course make them a multivalued parameter as well. +% +% +% +% \subsubsection{Paragraph-end parameters} +% +% None defined yet (but perhaps should) +% +% +% +% \subsection{Document level (user) commands} +% +% \subsubsection{Penalties} +% +% To give the user a chance to actually overwrite a penalty setting +% produced from environments or commands internally updating the +% galley structure, user level document commands like |\nopagebreak| +% do not modify the internal \PARM{penalty} but instead use a +% \PARM{user penalty}. If that parameter is set (i.e., non-empty) it +% will get used and the internal \PARM{penalty} that is normally +% applied will be ignored. This way, even in situations where the +% user request appears too early in the document (e.g., between +% environments where the following environment would modify +% \PARM{penalty} the desired outcome is ensured. +% +% \subsubsection{Vertical spaces} +% +% In contrast user commands for specifying vertical space will always +% add to the existing space.\footnote{Always? i can image to have the +% desire to explicitly set the space to a fixed value in which case i +% would like to ensure that the internal value for \PARM{vspace} is +% fully ignored. On the other hand this may not been sensible because +% it might be difficult for the user to know how big the space should +% be.} +% +% +% \subsection{Galley structure after lists/displays}\label{sec:endlist} +% +% After lists or a math display the continuation depends on whether +% the following text logically is part of the previous material or +% starts a new paragraph. This difference is coded in the source +% document by leaving or not leaving an empty line (|\par|). +% +% Depending on this the handling of the upcoming paragraph might +% differ in \PARM{penalty}, \PARM{vspace}, \PARM{indent} (and perhaps +% others) +% +% To allow for this a processing mechanism like this should be +% investigated\footnote{There is some concept code for this below but +% it is not finished!}: +% \begin{itemize} +% \item +% The environment that intends to make use of the structure sets a flag +% \item +% The values of parameters for the case of the paragraph continuing +% the previous material are specified by modifying the DGPVs. +% \item +% The values of parameters for the case that the next paragraph is +% to be considered independent are specified in a third structure +% (called XGPV for now) which is a plist like the SGPV (or part of +% it if we don't allow to modify any odd rubbish in that case, +% which is probably sensible) +% \item +% The code for the |\par| command is augmented in a way that if it +% is executed in vertical mode the following happens: +% \begin{itemize} +% \item +% The values in the XGPV are added to the DGPV values to allow +% for user level changes to be preserved. +% \item +% The flag above is reset so that following |\par| does not +% modify the DGPV further. +% \end{itemize} +% \end{itemize} +% The XGPV has to be stored away if a new galley level is initiated! +% +% +% +% +% +% \section{The low-level command interface} +% +% The commands described in this section are used to update the galley +% data structure. Their intended use is a) in kernel code, i.e., in +% parts that are already provided by the \LaTeXplus{} kernel such as +% the basic float mechanism and b) as building blocks for higher-level +% templates such as those defined by the module \texttt{xhj} or the +% module \texttt{xinitials}. +% They are not meant to be used directly when building classes. +% +% Their names are currently very strange and inconsistent and need to +% be normalized. +% +% +% +% \subsection{Manipulating the dynamic galley parameters values} +% +% To manipulate the dynamic parameter values of the galley structure a +% number of commands are available. As explained above changing the +% dynamic parameters effects the only next paragraph (or the next sequence +% of vertical objects between paragraphs) --- afterwards the +% parameters are reset to the values stored in their static counterparts. +% +% \noindent +% \DescribeMacro{\setDGPVthing:nn}\marg{id}\marg{value} \\ +% The |\setDGPVthing:nn| command takes a parameter \meta{id} (or more +% exactly its letter or letter sequence such as `j' or `ps') and +% assigns the \meta{value} to it. No processing of the value is +% undertaken. +% +% \noindent +% \DescribeMacro{\appendtoDGPVthing:nn}\marg{id}\marg{value} \\ +% \DescribeMacro{\appendtoDGPVthing:no} +% The |\appendtoDGPVthing:nn| also leaves the \meta{value} unchanged +% but appends it to the current value of the parameter. This is, for +% example, used to build the list of whatsits nodes in the \PARM{next +% whatsits} parameter. +% +% \noindent +% \DescribeMacro{\setDGPVdimension:nn}\marg{id}\marg{value} \\ +% \DescribeMacro{\addDGPVdimension:nn} +% \DescribeMacro{\maxDGPVdimension:nn} +% In contrast the family of |\...DGPVdimension:nn| commands process the +% \meta{value} by interpreting it as a calc dimension expression. The +% result is then set (|\set...|), or added to the current value +% (|\add...|), or compared with the current value (|\max...|) and the +% maximum assigned. +% +% \noindent +% \DescribeMacro{\setGALpenalty:n}\marg{value} \\ +% \DescribeMacro{\addGALpenalty:n} +% What is available for dimensions is also available for integer +% valued parameters. However, since there is only one such parameter +% (the \PARM{penalty}) at the moment, we provide a family of commands +% which take only a \meta{value} argument. +% +% \noindent +% \DescribeMacro{\setGALobject:n}\marg{value} \\ +% \DescribeMacro{\setGALbreak:n} +% The |\setGALobject:n| and |\setGALbreak:n| are special variants of +% the |\setDGPVthing:nn| command for the \PARM{object} and +% \PARM{nobreak flag} parameters, respectively.\footnote{should +% probably vanish} +% +% \noindent +% \DescribeMacro{\setGALleftparshape:nnn}\marg{\# of normal lines} +% \marg{default width} \marg{delta offset list} \\ +% \DescribeMacro{\setGALrightparshape:nnn} +% Defines a special parshape (that is it sets the \PARM{parshape} +% taking into account its current setting with respect to the galley +% measure) at the left or the right starting with +% a number of normal lines (first arg) followed by a number of special +% lines which are constructed assuming a hole of a certain width +% (second argument). The number of lines this hole exists vertically is +% defined by the number of delta offsets in the in comma separated +% third argument. The width of each delta is added to the nominal +% width of the hole thus allowing for special corrections on a line by +% line basis. +% +% +% +% \subsection{Manipulating the static galley parameters values} +% +% Manipulating the static galley parameters essentially means changing +% the default values to which these parameters are restored to at the +% end of each paragraph. These commands always set the corresponding +% dynamic parameter as well. +% +% \noindent +% \DescribeMacro{\setSGPVthing:nn} \marg{id} \marg{value}\\ +% Like |\setDGPVthing:nn| but for long-term changes, e.g., no +% processing of \meta{value} is undertaken. +% +% \noindent +% \DescribeMacro{\setSGPVdimension:nn} \marg{id} \marg{value} \\ +% Like |\setDGPVdimension:nn| but for long-term changes, e.g., the +% \meta{value} is evaluated using calc prior to assigning it to the +% parameter. +% +% There are no commands for making long-term changes to other parts of +% the interface. Mostly because they seemed to be unnecessary. If +% needed they could be added without much problem. +% +% +% +% \subsection{Manipulating the galley measure} +% +% In the current implementation the galley measure, i.e., the width of +% text lines and their indentation from the left are not represented +% by a galley parameter directly. Instead they are internally stored +% as part of the \PARM{parshape} (see discussion above). For +% this reason that parameter can't be (or rather shouldn't be) +% modified directly but only through the commands below and commands +% like |\setGALleftparshape:nnn| which know baout those dependencies +% and handle the update accordingly. +% +% \noindent +% \DescribeMacro{\setSGPVmeasure:nn} \marg{left-margin} +% \marg{line-width} \\ +% This command make a long-term change to the measure by setting the +% width of +% the line to \meta{line-width} and the width of the left margin to +% \meta{left-margin}. In addition it sets the registers |\linewidth| +% and |\@totalleftmargin| to these values (for inspection). +% +% \noindent +% \DescribeMacro{\addSGPVmeasure:nn} +% \marg{left-margin-increment} \marg{line-width-increment}\\ +% This command make a long-term change to the measure by incrementing the +% width of of the line with \meta{line-width-increment} and the width +% of the left margin with \meta{left-margin-increment}. In addition +% it sets the registers |\linewidth| +% and |\@totalleftmargin| to the resulting values (for inspection). +% +% +% +% +% +% \subsection{Saving and restoring SGPV changes} +% +% \DescribeMacro{\GALsavegalleystate:} \\ +% \DescribeMacro{\GALrestoregalleystate:} This pair of commands stores +% and retrieves the current state of the SGPVs and can be used with +% environments that want to make long term changes and revert to the +% old settings afterwards, i.e. use |\GALsavegalleystate:| at the +% beginning, before doing any modification, and then +% |\GALrestoregalleystate:| at the end. They should be called at the +% same level of grouping (as the saving is done locally) and with the +% current implementation they can't be called several times on the +% same level.\footnote{Or so i think; which is something we may not be +% able to leave as that} +% +% +% \subsection{Manipulating the behavior of \texttt{\textbackslash par}} +% +% The |\par| command in \TeX{} is perhaps the most troublesome item of +% the language for the simple reason that it can't be sucessfully +% trapped by the macro programmer and hidden from (mis)use. +% When \TeX{} sees an empty line it converts it into the token |\par| +% and this name is fixed and can't be changed. It is easy to provide +% special definitions for the action taken when this token is +% processed but there is no way to prevent somebody from overwriting +% those carefully designed interfaces by simply doing something like +% |\let\par\foo|. If this happens anything might go wrong and since +% |\par| is a name that can't be hidden from the user nor from the +% package designer the only thing one can do is to boldly state that +% \begin{center} +% \bfseries Manual changes to |\par| are not supported! +% \end{center} +% +% Having said this we now present the interfaces that can be used to give +% |\par| a special meaning within \LaTeXplus. It should be stressed +% that |\par| always has a special meaning within the galley mechanism +% and that direct changes to it, at best lead to incorrect formatting, +% far more likely however will lead to disaster. +% +% \noindent +% \DescribeMacro{\setGALnormalpar:}\\ +% This command defines |\par| to have its standard definition within +% the galley mechanism, i.e., if a paragraph is currently processed it +% will be finished (including all code necessary, e.g., execute end of +% paragraph hooks) and preparations are undertaken to initialize the +% data structure to be ready to processes inter-paragraph material +% and/or start a new paragraph. +% +% \noindent +% \DescribeMacro{\setGALignoredpar:n} \marg{error text}\\ +% The +% |\setGALignoredpar:n| changes |\par| so that it does nothing for +% a while, outputting the \meta{error text} after 3 successive +% |\par|s.\footnote{That command should probably be replaced in favor +% of the one below as it is quite dangerous if used in horizontal +% mode (see comments in the code section, there may be no way to +% gain control!)} +% +% \noindent +% \DescribeMacro{\setGALendlistpar:} +% A special definition for |\par| at the end of list like +% structures. The code for this is currently not functional, some +% ideas regarding this can be found in section~\ref{sec:endlist} +% and in the code section. +% +% \noindent +% \DescribeMacro{\GALignorepars:n}\marg{error text} \\ +% A sort of |\ignorespaces| but for spaces and |\par|s. Should of +% course only be used as the last command in expansion (and may need +% support within |\end| handling---the latter is not done) +% +% +% \section{Open issues} +% +% In this section unresolved issues or ideas to think about and +% perhaps implement are collected. There is no particular order to +% them. +% +% \begin{itemize} +% \item +% It seems advisable to change the way galleys are set up: don't +% automatically start a new galley with each vbox but instead start +% a galley only in dedicated ``galley-boxes'' such as the internal +% form of |\parbox| etc. The advantage is much less overhead, the +% disadvantage is that non-conforming packages (written without this +% mechanism in mind) will 99\% fall over while with the current setup +% they have a good chance to survive and produce more or less proper +% formatting. +% \item +% |\@totalleftmargin| and |\linewidth| need to be adequately dealt +% with, probably by integrating them properly into the data structure +% somehow at the parshape level. +% \item +% It is quite likely that we need more granularity on the interfaces +% for storing and restoring the galley state. There need to be a +% full store and restore for cases where an unrelated galley is +% started in the middle of some other galley (such as formatting a +% marginal paragraph in the middle of the main galley) but it is not +% appropriate to store and restore the whole galley state when +% formatting a list inside a galley (what is wanted there is to +% store and restore the outer measure, the outer parshape, etc.\ but +% not any registers which deal with penalties, vertical spaces +% between paragraphs and so on. So |\GALsavegalleystate:| needs some +% companion! +% \item +% Not properly integrated into the whole scheme are math displays +% (Michael Downes will hopefully come to rescue me here at some point). +% \end{itemize} +% +% +% +% \StopEventually{} +% +% \section{Implementation} +% +% Set up certain defaults including to ignore white space +% within the body of this package. \LaTeXe{} release needs to be +% recent because of changing some bits of the |\parbox| handling below. +% \begin{macrocode} +%<*package> +\NeedsTeXFormat{LaTeX2e}[1998/12/01] +\RequirePackage{ldcsetup} +% \end{macrocode} +% +% \begin{macrocode} +\RequirePackage{xhj} % taken out of this file +% \end{macrocode} +% +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% The code does use `:' characters in command names (basically +% inherited from expl3 and property list code I took from there for +% the first proto-type implementation). Right now it is a bit of a +% nuisance since using `:' should either be integrated into +% |\IgnoreWhiteSpace| and friends or otherwise probably not be +% used. +% \begin{macrocode} +\catcode`\:=11\relax +% \end{macrocode} +% +% +% \subsection{Tracing} +% +% \begin{macro}{\tracinggalleys} +% A complicated mechanism like the galley interface needs some +% tracing facilities. Here we provide some modeled after +% \TeX's internal low-level tracing functions. +% \begin{macrocode} +\def\tracinggalleys{\afterassignment\@tracinggalleys\count@} +%<-trace>\let\@tracinggalleys\relax +% \end{macrocode} +% +% If we compile this module without tracing than |\tracinggalleys| +% will scan away an integer assignment but otherwise does +% nothing. But if we docstrip with tracing included then depending +% on the integer values the following things happen: +% \begin{description} +% \item[0] No tracing. +% \item[1] All tracing info is written to the log file only. +% \item[2] All tracing info is written to the terminal. +% \item[3 and higher] All tracing info is written to the terminal +% and before it is presented a quick check for other internal +% \TeX{}-tracing is undertaken. If it looks as if |\tracingall| +% is currently used then various tracings are temporarily disable +% to avoid getting the output of the tracing being traced as +% well. This prevents getting many many uninteresting output +% lines which would otherwise appear. +% +% This value can only be used if e\TeX{} in extended mode is used +% as the formatter, as it sets |\tracingassigns|\footnote{Really +% useful that primitive, try it one day if you got stuck while +% macro writing, that alone is worth using e\TeX{} for.} which is +% not a primitive of \TeX. +% \end{description} +% +% \begin{macrocode} +%<*trace> +\def\@tracinggalleys{ + \ifcase \count@ + \let\GAL@typeout\@gobble +% \end{macrocode} +% +% We can't let |\Gal@typout| simply to |\wlog| if we don't want to see +% tracing on the screen since that does expand its argument and +% produces havoc in some cases, so here is a slightly slower variant. +% \begin{macrocode} + \or + \def\GAL@typeout ##1{ + \begingroup + \let\protect\@unexpandable@protect + \wlog {##1} + \endgroup + } +% \end{macrocode} +% If |\tracinggalleys| is set to 2 we show a lot of tracing data. +% \begin{macrocode} + \or + \let\GAL@typeout\typeout +% \end{macrocode} +% And another variant when lowlevel tracing is called for. This +% version does assume that e\TeX{} is being used as it tries to set +% |\tracingassigns|, so it will fail if this assumption is incorrect. +% \begin{macrocode} + \else + \def\GAL@typeout ##1{ + \ifnum\tracingmacros>\z@ + \begingroup + \tracingassigns\z@ + \tracingcommands\z@ + \tracingrestores\z@ + \tracingmacros\z@ + \typeout{##1} + \endgroup + \else + \typeout{##1} + \fi + } + \fi +} +%</trace> +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@typeout} +% This macro is used below to display some tracing info. By default +% no tracing happens. +% \begin{macrocode} +\let\GAL@typeout\@gobble +% \end{macrocode} +% \end{macro} +% +% +% +% \subsection{Taking away primitives from direct use} +% +% To make this mechanism work we have to shield the primitive \TeX{} +% parameters from direct access by the user or a package writer. We do +% this by giving them internal names of the type +% |\GAL@@|\meta{param-name} and the allocating under the original +% parameter name a suitable register to trap any direct access. +% +% We have to trap |\clubpenalty| and |\interlinepenalty|; both are used +% to prohibit page breaking in paragraphs. +% \begin{macrocode} +\let\GAL@@clubpenalty\clubpenalty +\newcount\clubpenalty +\let\GAL@@interlinepenalty\interlinepenalty +\newcount\interlinepenalty +% \end{macrocode} +% +% See comments below why this is not needed. +% \begin{macrocode} +%\let\GAL@@brokenpenalty\brokenpenalty +%\newcount\brokenpenalty +% \end{macrocode} +% +% And of course we have to trap |\everypar| since this token register +% is one of the central bits of the algorithm. It is used to gain +% control at the start of a new paragraph and actually put the stored +% galley data structure for inter-paragraph material onto the page. +% \begin{macrocode} +\let\GAL@@everypar\everypar +\newtoks\everypar +% \end{macrocode} +% +% Not sure if we really need to trap |\parindent|, anyway here it is: +% \begin{macrocode} +\let\GAL@@parindent\parindent \GAL@@parindent\z@ +\newdimen\parindent +% \end{macrocode} +% +% The |\parskip| parameter is a real nuisance, we really do not want +% it at all as we handle our inter-paragraph spaces ourself. However, +% we can't get rid of it, best we can do is to make it always zero. +% +% Setting the then alocated |\parskip| register will not have any +% effect at all.\footnote{Perhaps it should: i.e., at least produce a +% warning or error message.} +% \begin{macrocode} +\let\GAL@@parskip\parskip \GAL@@parskip\z@ +\newskip\parskip +% \end{macrocode} +% +% The next block is trapping those parameters which are responsible +% for the justification, ie +% \begin{macrocode} +\let\GAL@@leftskip\leftskip +\newskip\leftskip +\let\GAL@@rightskip\rightskip +\newskip\rightskip +\let\GAL@@parfillskip\parfillskip +\newskip\parfillskip \parfillskip\@flushglue +% \end{macrocode} +% +% And while we are at it, we might as well allocate two additional +% skips which are related to justification: |\GAL@@startskip| the +% counterpart to |\GAL@@parfillskip| at the beginning of the paragraph +% and |\GAL@@linefillskip| which will hold the space to be inserted +% before a forced newline (as in |\\|). +% \begin{macrocode} +\newskip\GAL@@startskip +\newskip\GAL@@linefillskip +% \end{macrocode} +% +% |\spaceskip| and |\xspaceskip| are needed when doing proper ragged +% settings so they are part of the interface. +% \begin{macrocode} +\let\GAL@@spaceskip\spaceskip +\newskip\spaceskip +\let\GAL@@xspaceskip\xspaceskip +\newskip\xspaceskip +% \end{macrocode} +% +% The next is not yet (but perhaps it should be as well). +% \begin{macrocode} +\let\GAL@@lineskip\lineskip +\newskip\lineskip +% \end{macrocode} +% +% +% +% \subsection{Some extra scratch registers} +% +% Those registers are needed by the mutator functions and we better +% not rely on general scratch registers (at least not for the +% moment). The box register is for the indentation box. +% \begin{macrocode} +\newcount\GAL@cnta +% \end{macrocode} +% +% \begin{macrocode} +\newskip\GAL@skipa +\newskip\GAL@skipb +% \end{macrocode} +% +% \begin{macrocode} +\newbox\GAL@boxa +% \end{macrocode} +% +% +% +% \subsection{Galley data structure}\label{sec:galley-concept-impl} +% +% \subsubsection{Original concepts} +% +% In earlier implementations of \texttt{galley2.dtx}, galley objects +% have been represented in the following fashion: +% +% \begin{itemize} +% \item the long range values are stored in a within one level in +% global a plist with the name |\GAL@static@hmode@plist| which is a +% property list keeping all individual galley values for hmode. The +% keys in the property list are of the form +% |\GAL@|\meta{letter(s)}|@|. +% \item a copy of this plist is saved away under the name +% |\GAL@static@hmode@|\meta{level-num}|@plist| just before we start +% a new level so that when returning to a level the previous state can +% be reconstructed.\footnote{Instead of doing a global save under a +% name associated with the level number we could probably simply +% save the list locally and use the savestack since each new level +% has to be always associated with a new group anyway!} +% \item the keys in the above plists are also used directly as global +% variables holding the actual current values of the galley object +% parameters which allows fast access. +% \item similar plists exists for vmode and perhaps we want even +% more\footnote{but perhaps not, putting the parameters in different +% plists is mainly a speed thing, we can use flags to reinit only +% things that have changed; the lists are shorter which makes +% property handling faster, etc, but it needs some careful studying +% at a later stage whether this is really beneficial---in principle +% there is no problem with keeping all parameters in a single plist.} +% \end{itemize} +% This means that to make a long-term change to some galley object +% parameter one has to change the property within the +% |\GAL@static@|\meta{h/v}|mode@plist|. Such a change is then +% propagated to both the saved version as well as the global key +% commands. +% +% \subsubsection{Current concepts} +% +% After some evaluation I decided to change this setup in favour of +% the following: +% +% \begin{itemize} +% \item Actual values are represented by global control sequences of +% the form |\GAL@|\meta{letter(s)}|@|. +% \item If they are supposed to be reset after each usage their +% long-term (static) value is recorded globally in +% |\GAL@|\meta{letter(s)}|@s|. +% \item When starting a new galley level saved versions of the +% dynamic parameters are stored locally in |\GAL@|\meta{letter(s)}|@l| +% and those for the static parameters are stored in +% |\GAL@|\meta{letter(s)}|@sl|. When the level is popped those values +% are used to restore the state of the parameters. A consequence of +% this setup is that starting a new galley state should always involve +% a new group level! +% \end{itemize} +% This means that to make a long-term change to some galley object +% parameter one has to change the the |\GAL@|\meta{letter(s)}|@s| +% parameter (if it exists) as well as the |\GAL@|\meta{letter(s)}|@| +% one. +% +% If a new parameter is added to this setup we have to modify the +% following functions below: |\GAL@init@static|, +% |\GAL@save@galleystate|, \\ +% |\GAL@restore@galleystate|, and +% |\GAL@init@dynamic@fully|. +% +% \begin{macro}{\GAL@init@static} +% The |\GAL@init@static| function initialises the static and dynamic +% parameters with fixed defaults. This is, for example, used when +% starting a new level. At a later state one probably want to be able +% to globally set even those defaults for a whole document, but for +% now this is probably okay. +% +% \begin{macrocode} +\def\GAL@init@static { + \gdef\GAL@b@s {\z@} + \gdef\GAL@p@s {\z@} + \gdef\GAL@v@s {-1sp} + \gdef\GAL@uv@s {\z@} + \gdef\GAL@up@s {} + \gdef\GAL@pw@s {} + \gdef\GAL@j@s {\z@\leftskip\rightskip\parfillskip + \spaceskip\xspaceskip\parfillskip\parindent} + \gdef\GAL@o@s {} + \gdef\GAL@ps@s {} + \gdef\GAL@i@s {\z@} + \gdef\GAL@nw@s {} + \gdef\GAL@q@s {} +% \end{macrocode} +% +% The definition of |\par| is kind of static.\footnote{Do we need +% to set the internal version of \texttt{\textbackslash everypar} +% as well?} +% \begin{macrocode} + \setGALnormalpar: +% \end{macrocode} +% +% Having the static parameter updated we have to initialise the +% dynamic ones as well. +% \begin{macrocode} + \GAL@init@dynamic@fully +% \end{macrocode} +% The seldom used parameters for linebreaking and +% hyphenation are not subject to the galley concept but are set for +% the whole galley. For this reason the code below should be moved +% outside this macro. +% +% We interface to a default template instance so that the default +% can be easily overwritten on the class level.\footnote{bad idea? +% good idea?} +% \begin{macrocode} + \UseInstance{hj}{default} +%% alternative +%% \UseInstance{hyphenation}{default} +%% \UseInstance{linebreak}{default} +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GALsavegalleystate:} +% The |\GALsavegalleystate:| function saves away a copy of the current +% static plists in a way that it can be retrieved when returning to +% the current level. In the new implementation this means locally +% saviing all the dynamic parameters to their local counterparts +% (i.e., |\GAL@|\meta{letter}|@| to |\GAL@|\meta{letter}|@|l) and the +% same for the static parameters. +% \begin{macrocode} +\def\GALsavegalleystate: { + \let\GAL@b@l \GAL@b@ + \let\GAL@p@l \GAL@p@ + \let\GAL@v@l \GAL@v@ + \let\GAL@uv@l \GAL@uv@ + \let\GAL@up@l \GAL@up@ + \let\GAL@pw@l \GAL@pw@ + \let\GAL@j@l \GAL@j@ + \let\GAL@o@l \GAL@o@ + \let\GAL@ps@l \GAL@ps@ + \let\GAL@i@l \GAL@i@ + \let\GAL@nw@l \GAL@nw@ + \let\GAL@q@l \GAL@q@ +% + \let\GAL@b@sl \GAL@b@s + \let\GAL@p@sl \GAL@p@s + \let\GAL@v@sl \GAL@v@s + \let\GAL@uv@sl \GAL@uv@s + \let\GAL@up@sl \GAL@up@s + \let\GAL@pw@sl \GAL@pw@s + \let\GAL@j@sl \GAL@j@s + \let\GAL@o@sl \GAL@o@s + \let\GAL@ps@sl \GAL@ps@s + \let\GAL@i@sl \GAL@i@s + \let\GAL@nw@sl \GAL@nw@s + \let\GAL@q@sl \GAL@q@s +% \end{macrocode} +% The current definition of |\par| is handled manually (really +% manually)\footnote{Now this is pretty dangerous but i'm not sure +% this can be avoided: if \texttt{\textbackslash par} is being +% manually changed outside the control of these macros we might end up +% in deep shit. For example the old definition of tabular does this +% and the result is pretty bad, ie endless loop with +% \texttt{\textbackslash par} being a noop. any ideas?} +% \begin{macrocode} + \let\saved@GAL@par\par +% \end{macrocode} +% We also have to track the state of the |\GAL@reassign@list|: +% \begin{macrocode} + \let\saved@GAL@reassign@list\GAL@reassign@list +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GALrestoregalleystate:} +% And here we have the reverse operation which is needed when we +% return to a previous level. +% \begin{macrocode} +\def\GALrestoregalleystate: { + \global\let\GAL@b@ \GAL@b@l + \global\let\GAL@p@ \GAL@p@l + \global\let\GAL@v@ \GAL@v@l + \global\let\GAL@uv@ \GAL@uv@l + \global\let\GAL@up@ \GAL@up@l + \global\let\GAL@pw@ \GAL@pw@l + \global\let\GAL@j@ \GAL@j@l + \global\let\GAL@o@ \GAL@o@l + \global\let\GAL@ps@ \GAL@ps@l + \global\let\GAL@i@ \GAL@i@l + \global\let\GAL@nw@ \GAL@nw@l + \global\let\GAL@q@ \GAL@q@l +% + \global\let\GAL@b@s \GAL@b@sl + \global\let\GAL@p@s \GAL@p@sl + \global\let\GAL@v@s \GAL@v@sl + \global\let\GAL@uv@s \GAL@uv@sl + \global\let\GAL@up@s \GAL@up@sl + \global\let\GAL@pw@s \GAL@pw@sl + \global\let\GAL@j@s \GAL@j@sl + \global\let\GAL@o@s \GAL@o@sl + \global\let\GAL@ps@s \GAL@ps@sl + \global\let\GAL@i@s \GAL@i@sl + \global\let\GAL@nw@s \GAL@nw@sl + \global\let\GAL@q@s \GAL@q@sl +% \end{macrocode} +% \begin{macrocode} + \global\let\par\saved@GAL@par + \global\let\GAL@reassign@list\saved@GAL@reassign@list +% \end{macrocode} +% As long as we to not set up the individual paragraph shape +% parameters each time (see comments in +% |\GAL@set@horizontal@objects|) we have to restore them at this +% point as well. +% \begin{macrocode} + \expandafter \setup@paragraph@justification \GAL@j@ +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\saved@GAL@par} +% Recover from confusion: the top-level definition of |\saved@GAL@par| +% should never get assigned to |\par| but in case it is (by getting +% the grouping wrong) we better try to recover +% gracefully\footnote{Gracefully meaning I haven't bothered with +% producing anything other than an undefined csname error :-)}, so +% instead of ending up with a |\par| being an undefined command we do +% the following: +% \begin{macrocode} +\def\saved@GAL@par{\ERROR\GAL@normal@par} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@init@dynamic@as@necessary} +% Whenever parameters got changed for one paragraph the +% |\GAL@reassign@list| gets extended with an assignment that resets +% the parameter back to its static value. The +% |\GAL@init@dynamic@as@necessary| then executes this list and afterwards +% define it to be empty. +% \begin{macrocode} +\def\GAL@init@dynamic@as@necessary { +%<*trace> + \GAL@typeout{Reinit~ parameters \on@line} + \GAL@typeout{\@spaces \meaning \GAL@reassign@list} +%</trace> + \GAL@reassign@list + \global\let\GAL@reassign@list\@empty +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@init@dynamic@fully} +% Sometimes we want to ensure that all parameter are set to their +% static values. This is done by the |\GAL@init@dynamic@fully| macro.. +% \begin{macrocode} +\def\GAL@init@dynamic@fully { +%<*trace> + \GAL@typeout{Reinit~ parameters \on@line} +%</trace> + \global\let\GAL@b@ \GAL@b@s + \global\let\GAL@p@ \GAL@p@s + \global\let\GAL@v@ \GAL@v@s + \global\let\GAL@uv@ \GAL@uv@s + \global\let\GAL@up@ \GAL@up@s + \global\let\GAL@pw@ \GAL@pw@s + \global\let\GAL@j@ \GAL@j@s + \global\let\GAL@o@ \GAL@o@s + \global\let\GAL@ps@ \GAL@ps@s + \global\let\GAL@i@ \GAL@i@s + \global\let\GAL@nw@ \GAL@nw@s + \global\let\GAL@q@ \GAL@q@s +% \end{macrocode} +% And since everything is as the static value there is nothing for +% us to reassign so be make this list empty. +% \begin{macrocode} + \global\let\GAL@reassign@list\@empty +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@reassign@list} +% The |\GAL@reassign@list| holds the parameters that need to be +% reset at the next paragraph or more exactly it holds the +% assignments that do the resetting. So by default this is empty. +% \begin{macrocode} +\let\GAL@reassign@list\@empty +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@prepare@reassign:NN} +% The |\GAL@prepare@reassign:NN| macro receives the internal names +% of dynamic and and static placeholder for a parameter and extends +% the |\GAL@reassign@list|. +% \begin{macrocode} +\def\GAL@prepare@reassign:NN #1#2{ +% \end{macrocode} +% It might pay off to make a quick check whether or not the value +% of the dynamic parameter really differs from those of the static +% one. If not we can avoid updating the |\GAL@reassign@list| which +% takes some time and further more makes later updates of this list +% slower.\footnote{This needs some empirical testing: if most +% of the time this test results in false then it might be better to +% remove it though. One such test indicated that removal might be +% better but this isn't far from being conclusive.} +% \begin{macrocode} + \ifx#1#2 + \else + \appendtoDGPV@internal:Nn\GAL@reassign@list + {\global \let #1 #2 } + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@prepare@reassign:n} +% In contrast |\GAL@prepare@reassign:n| takes only the id for a +% parameter, such as |v| or |up|. It also has some extra code to +% check if the parameter is actually one that has both dynamic and +% static incarnations.\footnote{In the current implementation this +% is probably always the case but if we re-add \texttt{m} and +% \texttt{h} we may not want to reset them on every paragraph but +% handle them always as static for the whole galley.} If not we +% don't need to reassign.\footnote{Furthermore, for speed +% consideration it might be advisable to internally always replaces +% the call to this command by \texttt{GAL@prepare@reassign:NN} +% since this will always saves at least one extra csname parsing.} +% \begin{macrocode} +\def\GAL@prepare@reassign:n #1{ + \expandafter\ifx \csname GAL@#1@s\endcsname \relax +%<*trace> + \GAL@typeout{Not~ reassigning~ for~ #1!} +%</trace> + \else + \expandafter + \GAL@prepare@reassign:NN + \csname GAL@#1@ \expandafter \endcsname + \csname GAL@#1@s \endcsname + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \subsubsection{Starting and ending a level} +% +% The |\GAL@start@level| command first saves away the current state +% and then starts a new group. This group (|\bgroup|) will be matched +% by the closing brace of the current ``vbox'' either the explicit |}| +% or an |\egroup| equivalent of that. The |\GAL@cleanup@level| which +% then gets into control is supposed to restore the state and finally +% issue and |\egroup| which will then actually end the box. +% +% \begin{macro}{\GAL@start@level} +% \begin{macrocode} +\def\GAL@start@level{ + \GALsavegalleystate: + \bgroup +%<*trace> + \advance\GAL@level@num\@ne + \GAL@typeout{Entering~ galley~ level:~ + \the\GAL@level@num~ \on@line} +%</trace> + \GAL@init@static + \@GAL@if@first@on@leveltrue % temp solution! + % see below + \aftergroup\GAL@cleanup@level} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@level@num} +% The counter is really only necessary if tracing is compiled in, +% however we define it always just to ensure that the allocation +% doesn't change if tracing is added. +% \begin{macrocode} +\newcount\GAL@level@num +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\if@GAL@if@first@on@level} +% This belongs to some hack which needs some better +% implementation. It signals that we are at the beginning of a galley. +% \begin{macrocode} +\newif\if@GAL@if@first@on@level +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@cleanup@level} +% \begin{macrocode} +\def\GAL@cleanup@level{ + \par + \GAL@finish@typesetting +%<*trace> + \GAL@typeout{Returning~ to~ galley~ level:~ \the\GAL@level@num~ \on@line} +%</trace> + \GALrestoregalleystate: + \egroup +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@finish@typesetting} +% At the end of a galley (if in vmode) we have to ensure that we +% don't have any dangling bits in the data structure (like +% untypeset specials or writes that want to make their appearance +% at the beginning of the next paragraph. This is what +% |\GAL@finish@typesetting| is supposed to take care +% of\footnote{one day}. +% \begin{macrocode} +\def\GAL@finish@typesetting {} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\everyvbox} +% We start a new galley with every vbox. +% \begin{macrocode} +\everyvbox{\GAL@start@level} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\insert} +% Interestingly enough |\everyvbox| is not triggered by |\inserts| +% even though those are also vboxes so we have to do it manually +% here (and that is a bit of a pain~\ldots). +% \begin{macrocode} +\let\@@insert\insert +% \end{macrocode} +% There are cases where after the |\insert| we have stuff like +% |\csname ...\endcsname| and to ensure that we don't fall over in +% that case our redefinition has to be a bit elaborate. Of course +% all this is only of interest if we stay with the current +% implementation of always automatically starting a galley. +% \begin{macrocode} +\long\def\insert #1#{\@insert{#1}} +\long\def\@insert #1#2{\@@insert#1{\GAL@start@level#2\par}} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@ignore@next@galley} +% \begin{macro}{\GAL@ignore@next@galley@vbox} +% We may not need the next two commands at all if we change from +% setting up a galley everywhere to setting up galleys only for +% ``minipage'' like vboxes. And i think we should! +% \begin{macrocode} +\def\GAL@ignore@next@galley{ + \everyvbox{\global\everyvbox{\GAL@start@level}} +} +\def\GAL@ignore@next@galley@vbox{ + \everyvbox{\global\everyvbox{\GAL@start@level}}\vbox +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \subsubsection{Using the galley data structure} +% +% \begin{macro}{\GAL@show@datastructure} +% Some tracing to show the state of the data structure. +% As some internal params take arbitrary content we have to be a bit careful +% displaying them. Needs (some:-) improvement to be useful. +% \begin{macrocode} +%<*trace> +\def \GAL@show@datastructure #1{ + \GAL@typeout{#1^^J + \@spaces nominal~ width~ =~ \the\hsize ^^J + \@spaces left~ indentation~ =~ \the\@totalleftmargin ^^J + \@spaces break~ switch~ (b)~ =~ \GAL@b@ \space (\GAL@b@s) ^^J + \@spaces v-penalty~ (p)~ =~ \GAL@p@ \space (\GAL@p@s) ^^J + \@spaces v-space~ (v)~ =~ \GAL@v@ \space (\GAL@v@s) ^^J + \@spaces user~ v-penalty~ (up)~ =~ \GAL@up@ ^^J + \@spaces user~v-space~ (uv)~ =~ \GAL@uv@ ^^J + \@spaces prev-whatits~ (pw)~ =~ \meaning \GAL@pw@ ^^J + \@spaces next-whatits~ (nw)~ =~ \meaning \GAL@nw@ ^^J + \@spaces parshape~spec~ (ps)~ =~ \GAL@ps@ \space (\GAL@ps@s) ^^J + \@spaces queries~ (q)~ =~ \meaning \GAL@q@ ^^J + \@spaces indent~ flag~ (i)~ =~ \GAL@i@ \space (\GAL@i@s) ^^J + \@spaces para~ object~ (o)~ =~ \meaning \GAL@o@ ^^J + \@spaces para~ justification~ (j)~ =~ \meaning \GAL@j@ } +} +%</trace> +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@use@on@para} +% The next function is called when \TeX{} switches to horizontal mode, +% i.e., at the start of a paragraph. +% +% \begin{macrocode} +\def\GAL@use@on@para{ +%<*trace> + \GAL@show@datastructure{Para~ start~ for~ galley~ + level~ \the\GAL@level@num \on@line} +%</trace> +% \end{macrocode} +% At the start of a new galley we do not want to have any vertical +% space being inserted not even a zero |\parskip| since that would +% mess up use of |\vtop| etc. The below is a sort of crude fix for +% the problem ie this is the old minipage switch. +% +% What about a redesign??? +% \begin{macrocode} + \if@GAL@if@first@on@level + \GAL@handle@first@para + \else +% \end{macrocode} +% +% +% We want to return to vmode without leaving too much trace. so we +% remove the indentation box and call |\endgraf|. All this is done +% in a group to keep an already setup |\parshape|, eg in a list. In +% fact we might want to have this parshape setting as part of the +% galley-objects but this is not done so far.\footnote{There is a +% problem with code like this which was the result of a pr in +% \LaTeXe. If the start of a paragraph is triggered by certain very +% special commands (such as encoding-specific accents that involve +% grouping) we might have the case that such a command already +% started a group and then triggers the paragraph mechanism which +% in turn triggers this macro. That may result in those groups to +% overlap in a bad way---needs some clear instruction perhaps +% \texttt{\textbackslash leavevmode} in all potential cases.} +% \begin{macrocode} + \begingroup + \global\setbox\GAL@boxa\lastbox + \endgraf + \GAL@set@vertical@objects +% \end{macrocode} +% Before reentering h-mode we better clear the everypar register or +% we end up in a loop: +% \begin{macrocode} + \GAL@@everypar{} + \noindent + \endgroup + \fi +% \end{macrocode} +% Instead of setting up the measure each time one could probably +% move this to the template setting things up (or not?) +% \begin{macrocode} + \GAL@set@measure + \GAL@set@horizontal@objects +% \end{macrocode} +% At this point during the processing the parameters are all +% reinitialised, i.e., anything not yet used will be +% lost!\footnote{This is important if you think about paragraph +% ending stuff which is not yet implemented} +% \begin{macrocode} + \GAL@init@dynamic@as@necessary +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\GAL@handle@first@para} +% Since this part of the code from above is not used that often it was +% placed into a separate command (for faster skipping). +% +% What needs to be done always? +% \begin{macrocode} +\def\GAL@handle@first@para { + \@GAL@if@first@on@levelfalse + \GAL@pw@ +% \end{macrocode} +% \begin{macrocode} + \@tempskipa \GAL@uv@ \relax + \ifdim \@tempskipa =\z@ \else +% \end{macrocode} +% \begin{macrocode} + \ifhmode + \begingroup + \global\setbox\GAL@boxa\lastbox + \endgraf + \vskip \@tempskipa + \GAL@@everypar{} + \noindent + \endgroup + \else + \vskip \@tempskipa + \fi + \fi +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@use@on@vobject} +% The other case where (part of) the galley data structure is going to +% be used is the case when we are already in vertical mode but want to +% append some vertical mode material (e.g., a rule, an inline float) +% or start some environment that likes to look like a paragraph even +% though it doesn't actually uses \TeX's low-level mechanisms (e.g., +% longtable?, tabbing, \ldots). +% \begin{macrocode} +\def\GAL@use@on@vobject{ +%<*trace> + \GAL@show@datastructure{V-object~ for~ galley~ + level~ \the\GAL@level@num \on@line} +%</trace> + \if@GAL@if@first@on@level + \GAL@handle@first@para + \else + \GAL@set@vertical@objects + \fi + \GAL@init@dynamic@as@necessary +} +% \end{macrocode} +% The use of this command should be followed by a |\nobreak| after the +% v-object or else we introduce an unwanted breakpoint due to the next +% |\parskip| being inserted. +% +% \end{macro} +% +% +% \begin{macro}{\GAL@set@vertical@objects} +% When setting the vertical components of the galley structure the +% following happens: +% \begin{itemize} +% \item First any whatsits for the previous para are +% inserted\footnote{A nobreak is probably not necessary at this +% point as the +% parskip should by now already be inserted so that the next +% thing happening is an explicit penalty anyway.} +% \item +% If a document user command for penalties as been used (i.e., when +% \PARM{user penalty} is none-empty) it take precidence and the internal +% penalty value is ignored. +% \item +% Otherwise the \PARM{break switch} is checked. If this greater +% zero a nobreak penalty is issued and \PARM{penalty} is ignored. +% \item +% Otherwise the \PARM{penalty} value is used. +% \end{itemize} +% +% \begin{macrocode} +\def \GAL@set@vertical@objects { + \GAL@pw@ + \penalty + \ifx \GAL@up@ \@empty + \ifnum \GAL@b@ > \z@ + \@M + \else + \GAL@p@ \relax + \fi + \else + \GAL@up@ \relax + \fi +% \end{macrocode} +% A user skip as supplied by |\vspace| etc.\ is going into a +% separate register to ensure that it will always have the effect +% of adding extra space independent of what surrounding +% environments do. +% +% The |\parskip| below is not the \TeX{} primitive (which is always +% zero) but a user level register which is only applied at this +% point if ever. +% \begin{macrocode} + \GAL@skipa \GAL@v@ \relax + \vskip \ifdim +% \end{macrocode} +% |\parskip| gets applied if we are between two paragraphs without +% any further space requests; this is signalled by |\GAL@v@| having +% a value of |-1sp| (its default). Of course it is in theory +% possible that this value is the result to modification of +% |\GAL@v@| but allowing for this saves us an extra flag or +% register that would otherwise be needed and checked every time. +% \begin{macrocode} + \GAL@skipa = -1sp \parskip +%<*trace> + \GAL@typeout{\parskip=\the\parskip\space applied} +%</trace> + \else + \GAL@skipa + \fi + \vskip \GAL@uv@ \relax +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@set@measure} +% Some comments on the next macro: +% not sure: do we better set parshape global? (can we?); of course it +% could and perhaps should be run inline, also we might instead add +% |\parshape| to the required content of |\GAL@ps@| so that we avoid +% the test and simply execute it always. +% +% \begin{macrocode} +\def \GAL@set@measure { + \parshape + \ifx\GAL@ps@\@empty + \z@ + \else + \GAL@ps@ + \fi +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\GAL@set@horizontal@objects} +% Once we are back in hmode we first output any waiting whatsits, then +% run any query setups, then +% look at the saved indentation box: if it is void we know that we had +% a paragraph started with \noindent otherwise we typeset some +% indentation then the galley object and finally a horizontal skip +% (might also want a break penalty there or even more stuff). +% +% \begin{macrocode} +\def \GAL@set@horizontal@objects { + \GAL@nw@ + \GAL@q@ +% \end{macrocode} +% The shape is now a multi-valued parameter so we pass it expanded +% and let |\setup@paragraph@justification| do the assignments if necessary. +% +% As a speedup measure we are comparing |\GAL@j@| to the saved +% version |\GAL@j@s|, if they are identical we assume that all +% components of the multi-valued parameter are already properly set +% up. This saves doing 8 assignments at every paragraph. The catch +% is, that a change to the static parameter (via |\setSGPVthing:nn| +% |s|) needs to be manually followed by running +% |\setup@paragraph@justification| (see definition of +% \texttt{justification} template).\footnote{Actually, +% that shortcut does not work correctly! Needs thought! So commented out for the +% moment!} +% \begin{macrocode} +% \ifx \GAL@j@ \GAL@j@s % what is the right test to suppress? +% \GAL@typeout{Not~ setting~ up~ paragraph~ shape} +% \else + \expandafter \setup@paragraph@justification \GAL@j@ +% \fi + \ifnum \GAL@i@ = \z@ + \ifvoid\GAL@boxa \else \hb@xt@ \GAL@@parindent{} \fi + \fi + \GAL@o@ \relax + \hskip \GAL@@startskip \relax + \setup@page@breaking@penalties \GAL@b@ +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setup@page@breaking@penalties} +% The way the following code is written (at the moment) +% |\clubpenalty|, |\interlinepenalty|, and |\brokenpenalty| are still +% available as user level registers so that setting up, say, the +% broken penalty default for the whole document is done via setting +% that particular register. +% +% Another observation is that we most likely do not have to set +% |\GAL@@brokenpenalty| at all (and if |\GAL@@interlinepenalty| is +% set to `nobreak' we can also leave |\GAL@@clubpenalty| alone) +% since if i read it right these penalties are additive so one +% large one should be sufficient. +% +% \begin{macrocode} +\def \setup@page@breaking@penalties #1{ + \GAL@@clubpenalty \clubpenalty + \GAL@@interlinepenalty \interlinepenalty +% \GAL@@brokenpenalty \brokenpenalty + \ifcase #1 +% 0 + \or +% 1 + \or +%2 + \GAL@@clubpenalty \@M +% \GAL@@brokenpenalty \@M + \or +%3 + \GAL@@interlinepenalty \@M +% \GAL@@brokenpenalty \@M + \else +% assume negative: this loops if called with a value greater than 3! so +% probably can't stay this way. + \setup@page@breaking@penalties {-#1} + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\setup@paragraph@justification} +% Setting up the inner paragraph shape, e.g., the justification is +% done by breaking up the multi-value parameter |s| into its 8 +% components.\footnote{Do one has to make those settings global? Check!} +% \begin{macrocode} +\def \setup@paragraph@justification #1 #2 #3 #4 #5 #6 #7 #8{ + \global \GAL@@startskip #1 \relax + \global \GAL@@leftskip #2 \relax + \global \GAL@@rightskip #3 \relax + \global \GAL@@parfillskip #4 \relax + \global \GAL@@spaceskip #5 \relax + \global \GAL@@xspaceskip #6 \relax + \global \GAL@@linefillskip#7 \relax + \global \GAL@@parindent #8 \relax +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Handling of \texttt{\textbackslash par}} +% +% Depending on the state of the machinery |\par| might a get different +% definition. +% +% \begin{macro}{\GAL@normal@par} +% In most cases |\par| will be |\let| to |\GAL@normal@par|. +% \begin{macrocode} +\def \GAL@normal@par { + \begingroup + \ifvmode + \endgraf + \else %% For error-trapping needs + %% \ifinner \ifhmode etc cases +% \end{macrocode} +% At this point we might want to add and end par hook (not done); +% if we are not adding one then this definition can be optimised a lot +% (moving |\endgraf| up and using |\ifhmode| instead of the above. +% \begin{macrocode} + \endgraf + %%%% NOTE: this puts us into vmode with the para on the galley + %%%% AND rignt here we have stuff that has migrated + %%%% (eg vadjust stuff) from the last line!!! + \nobreak + \fi + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@@par} +% \LaTeX's saved version of the original |\par| primitive now needs +% actually run |\GAL@normal@par| to trick \LaTeX{} into accepting +% this redefinition. This is needed at least as long as if we run +% with a mixture of old and new code. +% \begin{macrocode} +\let\@@par\GAL@normal@par +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@endlist@par} +% +% Another potential definition of |\par| comes into play when we +% are at the end of a list environment and want to take different +% actions depending on getting a continution of the paragraph or a +% real end. This code is not functional! +% +% ATTENTION: most likely either have to set those locally or have +% to save the state of |\par| as well! And anyway it is not +% finished code yet!!!! +% +% \begin{macrocode} +%<*unfinished> +\def \GAL@endlist@par { + \begingroup + \ifvmode + \addDGPVdimension:nn v \GAL@v@X + \addDGPVdimension:nn i \GAL@i@X + \addGALpenalty:n \GAL@p@X + \setGALnormalpar: + \else + \endgraf + \nobreak + \fi + \endgroup +} +%</unfinished> +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setGALnormalpar:} +% The |\setGALnormalpar:| states that we are in normal operation. +% \begin{macrocode} +\def\setGALnormalpar:{ + \global\let\par\GAL@normal@par +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setGALendlistpar:} +% The |\setGALendlistpar:| states that we want to handle the end +% of list case. +% \begin{macrocode} +%<*unfinished> +\def\setGALendlistpar:{ + \global\let\par\GAL@endlist@par +} +%</unfinished> +% \end{macrocode} +% \end{macro} +% +% +% For ignoring |\par| commands we currently have two functions. +% +% \begin{macro}{\setGALignoredpar:n} +% The |\setGALignoredpar:n| command disables |\par| altogether and +% hopes that the beginning of another paragraph shows up soon +% (three |\par|s are allowed). If not it issues an error message +% (arg 1) and redefines |\par| to be |\GAL@normal@par|. +% \begin{macrocode} +\def \setGALignoredpar:n #1 { + \ifvmode + \global \par@deathcycles \z@ + \global\let\par\GAL@ignored@par + \gdef\GAL@ignored@par@error{#1} + \appendtoDGPVthing:nn q \setGALnormalpar: +% \end{macrocode} +% Not sure what should be done if this gets executed in hmode: a) +% ignore the request b) output an error message c) run it and with +% it have the rest of the document being typeset into a single +% paragraph :-)? Since c) isn't really an option we have to take +% some precaution, for the moment i have added an error but perhaps +% this should be restricted to appear really only in hmode as an +% error not in a |\write|, say, so maybe the test should be for +% hmode --- or perhaps the whole commands should be removed in +% favour of the one below. +% \begin{macrocode} + \else + \ERROR \setGALnormalpar: \par + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GAL@ignored@par} +% Helper function for |\setGALignoredpar:n|. +% \begin{macrocode} +\def\GAL@ignored@par{ + \global \advance\par@deathcycles \@ne + \ifnum \par@deathcycles > \thr@@ + \PackageError{galley2}\GAL@ignored@par@error\@ehd + \setGALnormalpar: + \par + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\GALignorepars:n} +% An alternative is to explicitly look out for |\par| and spaces +% (the point being that this immediately set the definition of +% |\par| back to its normal value if anything else is encountered). +% Again up to three |\par|s are accepted otherwise we get an error +% message. +% \begin{macrocode} +\def \GALignorepars:n #1 { + \global \par@deathcycles \z@ + \global\let\par\GAL@ignore@next@pars + \gdef\GAL@ignored@par@error{#1} + \GAL@ignore@next@pars +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\GAL@ignore@next@pars} +% And here is a helper for |\GALignorepars:n|. +% \begin{macrocode} +\def\GAL@ignore@next@pars { + \global \advance\par@deathcycles \@ne + \ifnum \par@deathcycles > \thr@@ + \PackageError{galley2}\GAL@ignored@par@error\@ehd + \setGALnormalpar: + \par + \fi + \@ifnextchar\par{}{\setGALnormalpar:} +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Support for paragraph shapes} +% +% +% \begin{macro}{\GAL@for} +% Next macro is a reimplementation of |\@for| to get rid of the |:| +% \begin{macrocode} +\long\def\GAL@for#1#2\do#3{% + \expandafter\def\expandafter\@fortmp\expandafter{#2}% + \ifx\@fortmp\@empty \else + \expandafter\@forloop#2,\@nil,\@nil\@@#1{#3}\fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\parshape@setup} +% The |\parshape@setup| macro provides a low-level interface for +% declaring special parshapes for the upcoming paragraph. It is +% especially tuned to deal with the more common cases like +% providing space for an initial or for an inline figure. It takes +% six arguments with the following meaning: +% \begin{itemize} +% \item If a hole is to be cut on the left of the paragraph the +% first argument should be |{\the\parshape@lineindent}| otherwise +% |\@totalleftmargin| (hole on the right). At the moment there is +% no provision for special shapes on both sides of the +% paragraph.\footnote{This is low-level but still more than awkward +% so probably should be replaced by something nicer one day.} +% \item +% The second argument gives the indentation to be used for all +% lines following the last special line. Typical value would be +% |\@totalleftmargin|, or in case of setting up hanging paragraphs, +% |\@totalleftmargin+<amount of hang>|. More exactly this indentation +% is assumed to be what is needed if this would have been a normal +% paragraph. It is therefore also added to the special lines. +% \item +% The third argument gives the line width for all lines following +% the last special line. Typical argument might be |\linewidth| or +% in case of hanging paragraphs +% |\linewidth+<amount of hang>|.\footnote{rewrite +% description of this and previous item} +% \item +% The forth argument gives the number of lines before the first special +% line (in case of an initial this would be 0 typically). +% \item +% The fifth argument gives an initial amount to be left free on all +% special lines. +% \item +% Finally the sixth argument specifies the special lines as a comma +% separated lists of dimensions. These dimensions are deltas to the +% space specified in the forth argument. +% \end{itemize} +% +% Running this command has several effects: +% \begin{itemize} +% \item +% The |\GAL@ps@| parameter is getting updated, ie it receives the +% area parshape spec. +% \item +% In the command |\parshape@firstlineindent| the indent of the +% first special line (not taking into account the standard line +% indentation) is made available for use by an +% application. This can be used to get to the left point on the +% line to insert an initial character or a figure. +% \end{itemize} +% +% \begin{macrocode} +\def \parshape@setup #1 #2 #3 #4 #5 #6{ +% \end{macrocode} +% +% \begin{macrocode} + \setlength\@tempdima{#2} + \setlength\@tempdimb{#3} + \global\let\GAL@ps@\@gobble % remove upcoming space below +% \end{macrocode} +% +% \begin{macrocode} + \parshape@linecnt \z@ + \@whilenum \parshape@linecnt < #4 \do + { \xdef\GAL@ps@{\GAL@ps@\space + \the\@tempdima\space \the\@tempdimb + } + \advance \parshape@linecnt \@ne + } +% \end{macrocode} +% +% \begin{macrocode} + \GAL@for\parshape@next#6\do + { + \advance\parshape@linecnt\@ne + \setlength\parshape@lineindent{\@tempdima+#5+\parshape@next} + \setlength\parshape@linewidth + {\@tempdima+\@tempdimb-\parshape@lineindent} + +% \end{macrocode} +% +% \begin{macrocode} +% \setlength\parshape@linewidth +% {\@tempdimb-#5-(\parshape@next)} +% \setlength\parshape@lineindent +% {\@tempdima+\@tempdimb-\parshape@linewidth} +% \end{macrocode} +% +% If we setting up the first special line we record the indentation +% used compared to a normal paragraph at this point. The +% |\parshape@firstlineindent| is not part of the galley structure +% thus we store it locally. +% \begin{macrocode} + \ifnum\parshape@linecnt=\@ne + \@tempdimc \parshape@lineindent + \advance\@tempdimc -\@tempdima + \edef\parshape@firstlineindent{\the\@tempdimc} + \fi +% \end{macrocode} +% +% \begin{macrocode} + \xdef\GAL@ps@{\GAL@ps@\space + #1\space + \the\parshape@linewidth} + } +% \end{macrocode} +% +% \begin{macrocode} + \advance\parshape@linecnt\@ne + \xdef\GAL@ps@{\the\parshape@linecnt\space + \GAL@ps@\space + \the\@tempdima\space \the\@tempdimb} +%<*trace> + \GAL@typeout{\space\space set~ ps = \GAL@ps@}% +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \GAL@prepare@reassign:NN \GAL@ps@ \GAL@ps@s +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macrocode} +\newcount\parshape@linecnt +\newlength\parshape@lineindent +\newlength\parshape@linewidth +% \end{macrocode} +% +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% \subsection{Short-term mutators} +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% All these functions only modify the DGPV, i.e., the one that gets +% reset after use. +% +% +% \subsubsection{Dimensions (skips and dimens)} +% +% +% For setting galley parameters of type skip or dimen we provide +% functions which take as their first argument an identifier +% (typically a single character) that identifies the parameter to +% change, e.g., `v' for vertical skip or `i' for indentation and as +% second argument a dimension (for setting the parameter to this +% value or adding this value or using the maximum of the old and the +% new value, etc).\footnote{They currently work using skip registers +% internally which means that it is up to the programmer to ensure +% that a dimen parameter gets passed only dimen values without plus +% or minus parts.} +% +% +% +% \begin{macro}{\setDGPVdimension:nn} +% |\setDGPVdimension:nn| sets the parameter specified by the first +% argument to the value given as the second argument. +% \begin{macrocode} +\def\setDGPVdimension:nn #1#2{% #1=v/h #2=value + \calc@assign@skip\GAL@skipb{#2} +%<*trace> + \GAL@typeout{\space\space set~ #1 = #2 = \the\GAL@skipb}% +%</trace> + \expandafter \xdef + \csname GAL@#1@\endcsname + {\the\GAL@skipb} + \GAL@prepare@reassign:n{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\addDGPVdimension:nn} +% +% |\addDGPVdimension:nn| add to the parameter specified by the first +% argument the value given as the second argument. +% \begin{macrocode} +\def\addDGPVdimension:nn #1#2{% #1=v/h/... #2=value + \GAL@skipb\csname GAL@#1@ \endcsname\relax +% \end{macrocode} +% Since the value of -1sp is (at least for the v parameter) used as +% a special flag we are a bit careful when adding so that we are +% not off by -1sp: this is not visible but in certain situations +% \TeX{} might be upset even by this tiny amount.\footnote{Really +% necessary?} +% \begin{macrocode} + \ifdim\GAL@skipb=-1sp + \calc@assign@skip\GAL@skipb{#2} + \else + \calc@assign@skip{\advance\GAL@skipb}{#2} + \fi +%<*trace> + \GAL@typeout{\space\space set~ #1 =+ #2 = \the\GAL@skipb} +%</trace> + \expandafter + \xdef + \csname GAL@#1@\endcsname + {\the\GAL@skipb} + \GAL@prepare@reassign:n{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\maxDGPVdimension:nn} +% |\maxDGPVdimension:nn| compares the current value of the +% parameter specified by the first argument with the value given as +% the second argument and stores the maximum of +% them.\footnote{Current \LaTeX's \texttt{\textbackslash addvspace} +% works quite differently and we may have to provide something else +% here (or in addition)} +% \begin{macrocode} +\def\maxDGPVdimension:nn #1#2{ + \GAL@skipa\csname GAL@#1@\endcsname\relax + \calc@assign@skip\GAL@skipb{#2} + \ifdim\GAL@skipa<\GAL@skipb + \expandafter + \xdef + \csname GAL@#1@\endcsname + {\the\GAL@skipb} + \GAL@prepare@reassign:n{#1} + \fi +%<*trace> + \GAL@typeout{\space\space set~ #1 = + max(\the\GAL@skipa,\the\GAL@skipb) ^^J\@spaces\@spaces + = \csname GAL@#1@\endcsname} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \subsubsection{Integers} +% +% From previous coding we still have things like |\setGALpenalty:n| --- +% i guess one could normalise this to an interface like +% |\setGALinteger| \ldots +% +% \begin{macro}{\setGALpenalty:n} +% we can either set the `penalty' object or add to it. To speed things +% up we use a mixture of calc and low-level \TeX{} conventions +% +% \begin{macrocode} +\def\setGALpenalty:n #1{% + \calc@assign@count\GAL@cnta{#1} + \xdef \GAL@p@ {\the\GAL@cnta} +%<*trace> + \GAL@typeout{\space\space set~ p = #1 = \the\GAL@cnta} +%</trace> + \GAL@prepare@reassign:NN \GAL@p@ \GAL@p@s +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\addGALpenalty:n} +% +% \begin{macrocode} +\def\addGALpenalty:n #1{% + \GAL@cnta \GAL@p@ \relax + \calc@assign@count{\advance\GAL@cnta}{#1} + \xdef \GAL@p@ {\the\GAL@cnta} +%<*trace> + \GAL@typeout{\space\space set~ p += #1 = \the\GAL@cnta} +%</trace> + \GAL@prepare@reassign:NN \GAL@p@ \GAL@p@s +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setGALbreak:n} +% The |\setGALbreak:n| sets the switch that controls page breaking +% \begin{macrocode} +\def\setGALbreak:n #1{% values 0, 1, 2, or 3 +%<*trace> + \GAL@typeout{\space\space set~ b = #1 } +%</trace> + \gdef \GAL@b@ {#1} + \GAL@prepare@reassign:NN \GAL@b@ \GAL@b@s +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsubsection{Objects and thingies in general} +% +% \begin{macro}{\setGALobject:n} +% +% For the `o' object i've implemented only a `set' command so far +% (have to see what kind of usage this gets first) +% +% \begin{macrocode} +\def\setGALobject:n #1{ + \gdef \GAL@o@ {#1} + \GAL@prepare@reassign:NN \GAL@o@ \GAL@o@s +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setDGPVthing:nn} +% A generalised version of that is |\setDGPVthing:nn|. +% \begin{macrocode} +\def\setDGPVthing:nn #1 #2{ + \expandafter \gdef \csname GAL@#1@\endcsname {#2} + \GAL@prepare@reassign:n{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\appendtoDGPVthing:nn} +% \begin{macro}{\appendtoDGPVthing:no} +% And here is another one which appends code to the right of the +% parameter: +% \begin{macrocode} +\def\appendtoDGPVthing:nn #1#2{ + \expandafter\appendtoDGPV@internal:Nn\csname GAL@#1@\endcsname {#2} + \GAL@prepare@reassign:n{#1} +} +\def\appendtoDGPVthing:no #1#2{ + \expandafter\appendtoDGPV@internal:No\csname GAL@#1@\endcsname {#2} + \GAL@prepare@reassign:n{#1} +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\appendtoDGPV@internal:Nn} +% \begin{macro}{\appendtoDGPV@internal:No} +% These are internals which look suspiciently like some macros +% already present a million times in \LaTeX{}. +% \begin{macrocode} +\def\appendtoDGPV@internal:Nn #1 #2{ + \expandafter \gdef \expandafter #1 \expandafter + {#1 #2} +} +\def\appendtoDGPV@internal:No #1 #2{ + \expandafter\appendtoDGPV@internal:Nn\expandafter #1\expandafter {#2} +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsubsection{Paragraph shapes} +% +% \begin{macro}{\setGALleftparshape:nnn} +% \begin{macro}{\setGALrightparshape:nnn} +% Setting a parshape on the left or the right for the next +% paragraph, e.g., an initial. Not implemented so far is doing +% something special on both sides. +% \begin{macrocode} +\def \setGALleftparshape:nnn { + \parshape@setup {\the\parshape@lineindent} \@totalleftmargin + \linewidth } +\def \setGALrightparshape:nnn { + \parshape@setup \@totalleftmargin \@totalleftmargin \linewidth +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\GALhangfrom:n} +% And here a reimplementation of |\@hangfrom| but obeying +% |\@totalleftmargin| indentation. +% \begin{macrocode} +\def \GALhangfrom:n #1 { + \setbox\@tempboxa\hbox{{#1}} + \parshape@setup {\the\parshape@lineindent} + {\@totalleftmargin+\wd\@tempboxa} + {\linewidth-\wd\@tempboxa} + \z@ + \z@ + {-\wd\@tempboxa} + \noindent\box\@tempboxa} +\let \@hangfrom \GALhangfrom:n +% \end{macrocode} +% \end{macro} +% +% +% +% +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% \subsection{Long-term mutators} +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% The following functions now modify the SGPV, i.e., modify the +% values that are used as defaults unless overwritten for an +% individual paragraph. Right now I don't see any purpose in providing +% computation support at this level other than something like calc +% expansion; so need one function per parameter type. Otherwise a +% single function would be sufficient. +% +% \subsubsection{Objects and thingies in general} +% +% \begin{macro}{\setSGPVthing:nn} +% So here is one that simply stores away the value in the right plist +% under the right key. In addition we also directly update the key +% command itself to avoid having to run something like +% |\GAL@init@hmode| afterwards. +% \begin{macrocode} +\def\setSGPVthing:nn #1 #2 { + \setDGPVthing:nn {#1} {#2} + \global\expandafter + \let\csname GAL@#1@s \expandafter\endcsname + \csname GAL@#1@ \endcsname +} +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Dimensions (skips and dimens)} +% +% \begin{macro}{\setSGPVdimension:nn} +% The |\setSGPVdimension:nn| first sets the dynamic part of the +% parameter (which is done using calc expansion) followed by +% updating the static part of the parameter. +% \begin{macrocode} +\def\setSGPVdimension:nn #1 #2 { + \setDGPVdimension:nn {#1} {#2} + \global\expandafter + \let\csname GAL@#1@s \expandafter\endcsname + \csname GAL@#1@ \endcsname +} +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Paragraph shapes} +% +% \begin{macro}{\setSGPVmeasure:nn} +% Dealing with the parshape: the long term modification is essentially +% setting the measure and to support old \LaTeX{} code also sets +% |\linewidth| and |\@totalleftmargin| (but see comments on this somewhere!) +% +% \begin{macrocode} +\def \setSGPVmeasure:nn #1 #2 { + \setlength\@totalleftmargin{#1} + \setlength\linewidth{#2} + \xdef\GAL@ps@s{\@ne\space + \the\@totalleftmargin\space \the\linewidth} + \global\let\GAL@ps@\GAL@ps@s +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\addSGPVmeasure:nn} +% This is a variant modifies the measure (the name is +% horrible) by adding to |\@totalleftmargin| and |\linewidth|. Note +% that you normally need to substract from |\linewidth| if +% |\@totalleftmargin| is enlarged! +% \begin{macrocode} +\def \addSGPVmeasure:nn #1 #2 { + \addtolength\@totalleftmargin{#1} + \addtolength\linewidth{#2} + \xdef\GAL@ps@s{\@ne\space + \the\@totalleftmargin\space \the\linewidth} + \global\let\GAL@ps@\GAL@ps@s +} +% \end{macrocode} +% \end{macro} +% +% +% +% \subsubsection{Integers} +% +% No functions provided. For consistency reasons there probably should +% some in the end. +% +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% \subsection{Higher level commands} +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% +% \begin{macro}{\vspace} +% The |*| of |\vspace| is parsed but not handled in this +% implementation yet! +% \begin{macrocode} +\DeclareDocumentCommand \vspace {s m } + { + \addDGPVdimension:nn{uv}{#2} + } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\addvspace} +% |\addvspace| is quite a bit different to the latex original, this +% needs changing! +% \begin{macrocode} +\def\addvspace#1{ + \maxDGPVdimension:nn{v}{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\addpenalty} +% \begin{macrocode} +\def\addpenalty#1{ + \addGALpenalty:n{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% \subsection{Templates (first ideas)} +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% Code in this section is essentially left over from previous +% versions. Most templates have been moved to different files already. +% +% The endlist template is rubbish and just for testing the concept +% itself! and not finished either! +% +% \begin{macrocode} +\RequirePackage{template} +\RequirePackage{xparse} +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplateType{endlist}{0} + +\DeclareTemplate{endlist}{std}{0}{ + penalty =+C \GAL@p@ , + vspace =+L \GAL@v@ , + parindent =+L \GAL@i@ , + par-penalty =+C [0] \GAL@p@X , + par-vspace =+L [\z@] \GAL@v@X , + par-parindent =+L [\z@] \GAL@i@X , + } + {\DoParameterAssignments + \setGALendlistpar:} + +\DeclareInstance{endlist}{list}{std}{ + penalty = 999 , + vspace = 10pt , + parindent = 0pt , + par-penalty = -1000 , + par-vspace = 5pt , + par-parindent = 10pt , + } +% \end{macrocode} +% +% +% +% +% \subsection{Initialisation} +% +% \begin{macrocode} +\GAL@init@static % this is to be after the templates by now + +\GAL@@everypar{\GAL@use@on@para\the\everypar} + +% \end{macrocode} +% +% We need to initialize again at start of document i fear to ensure +% that stuff like the hyphenation is set up properly (this needs some +% further thoughts!) +% \begin{macrocode} +\AtBeginDocument { + \GAL@init@static % this is to be after the templates by now +} +% \end{macrocode} +% +% \section{Updated code from \texttt{latex.ltx}} +% +% There are a bunch of additional code lines which are originally from +% \texttt{latex.ltx} and have been updated (in part) to use the new +% mechanism. This isn't really worth printing as most of that is not +% fully done or obsolete by redefinition of, say, code for lists, +% etc. But one might want to have a look at it at some stage. For this +% reason the code contains an |\end{document}| at this point. which +% you may or may not want to remove. +% +% \PrintIndex +% +% \end{document} +% +% \begin{macrocode} +\def\@@line#1{\GAL@use@on@vobject\hb@xt@\hsize{#1}\nobreak} + +\long\def \@savemarbox #1#2{% + \global\setbox #1% + \color@vbox + \vtop{% + \hsize\marginparwidth + \@parboxrestore + \@marginparreset + #2% + \par % needed nowadays! + \@minipagefalse + \outer@nobreak + }% + \color@endbox +} + +\long\def\@footnotetext#1{\insert\footins{% + \reset@font\footnotesize + \interlinepenalty\interfootnotelinepenalty + \splittopskip\footnotesep + \splitmaxdepth \dp\strutbox \floatingpenalty \@MM + \hsize\columnwidth \@parboxrestore + \protected@edef\@currentlabel{% + \csname p@footnote\endcsname\@thefnmark + }% + \color@begingroup + \@makefntext{% + \rule\z@\footnotesep\ignorespaces#1\@finalstrut\strutbox\par}% %ditto!!! + \color@endgroup}}% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% all latex.ltx commands that involved the @nobreak flag +% +% most of them have been modified to use the new structure but not all +% and not all correctly (see comments within the code + +%<*trace> +\def\showGALcmd#1{\GAL@typeout{In~#1: \the\GAL@level@num~ \on@line}} +%</trace> + +\def\@afterheading{ +%<*trace> + \showGALcmd{@afterheading} +%</trace> + \if@afterindent \else + \setDGPVthing:nn i \@ne + \fi + \setGALbreak:n 2 +} + +\def\nofiles{% +%<*trace> + \showGALcmd{} +%</trace> + \@fileswfalse + \typeout{No auxiliary output files.^^J}% + \long\def\protected@write##1##2##3% + {\write\m@ne{}% +% +% i think that the following code can simply vanish since if we are in +% vmode and the \PARM{break flag} is set then the GAL mechansim will +% automatically add a penalty 10000 at the right point; correct? +% +%\if@nobreak\ifvmode\nobreak\fi\fi}% + } + \let\makeindex\relax + \let\makeglossary\relax} + +\long\def \protected@write#1#2#3{% +%<*trace> + \showGALcmd{protected@write} +%</trace> + \begingroup + \let\thepage\relax + #2% + \let\protect\@unexpandable@protect + \edef\reserved@a{\write#1{#3}}% + \appendtoDGPVthing:no {nw} \reserved@a + \endgroup +% +% see above +% +% \if@nobreak\ifvmode\nobreak\fi\fi +} + +\def\markboth#1#2{\gdef\@themark{{#1}{#2}}{% +%<*trace> + \showGALcmd{} +%</trace> + \let\protect\@unexpandable@protect + \let\label\relax \let\index\relax \let\glossary\relax + \mark{\@themark}}% +% +%\if@nobreak\ifvmode\nobreak\fi\fi +} + +\def\markright#1{{\let\protect\@unexpandable@protect +%<*trace> + \showGALcmd{} +%</trace> + \let\label\relax \let\index\relax \let\glossary\relax + \expandafter\@markright\@themark + {#1}\mark{\@themark}}% +% +%\if@nobreak\ifvmode\nobreak\fi\fi +} + +\def \newpage {% +%<*trace> + \showGALcmd{newpage} +%</trace> + \if@noskipsec + \ifx \@nodocument\relax + \leavevmode + \global \@noskipsecfalse + \fi + \fi + \if@inlabel + \leavevmode + \global \@inlabelfalse + \fi +% +% newpage is supposed to stop any \PARM{nobreak flag}, so the right +% approach is probably something like +% + \ifnum \GAL@b@ > \z@ + \setGALbreak:n 0 + \fi +% +% \if@nobreak \@nobreakfalse \everypar{}\fi +% + \par + \vfil + \penalty -\@M} +% +% +% the |\@arrayparboxrestore| nothing else than initialising a new +% galley level (in the old \LaTeX) so most of what is there needs +% either to vanish or to get integrated into the startup code of a new +% galley (not done yet) +% +\def\@arrayparboxrestore{% +%<*trace> + \showGALcmd{@arrayparboxrestore} +%</trace> +% +% again nothing to do (i think): if used as part of a minipage or +% parbox we are at a new level, otherwise we are probably not supposed +% to change that value +% +% \let\if@nobreak\iffalse + \let\if@noskipsec\iffalse + \let\par\@@par + \let\-\@dischyph + \let\'\@acci\let\`\@accii\let\=\@acciii + \parindent\z@ \parskip\z@skip + \everypar{}% + \linewidth\hsize + \@totalleftmargin\z@ + \leftskip\z@skip \rightskip\z@skip \@rightskip\z@skip + \parfillskip\@flushglue \lineskip\normallineskip + \baselineskip\normalbaselineskip + \sloppy} + +\def\@startsection#1#2#3#4#5#6{% +%<*trace> + \showGALcmd{@startsection} +%</trace> + \if@noskipsec \leavevmode \fi + \par + \@tempskipa #4\relax + \@afterindenttrue + \ifdim \@tempskipa <\z@ + \@tempskipa -\@tempskipa \@afterindentfalse + \fi +% +% the section case is interesting since the @nobreak flag is used for +% two things: a) to suppress a penalty if heading follow each other +% and be to suppress a skip in this case. This works because in latex +% the @nobreak switch is only set in the heading context (so is +% actually something like ``heading just seen flag'' +% +% not sure how to model something like this in general, for the moment +% i look at the \PARM{nobreak flag} but this is not correct! +% +% \if@nobreak +% \everypar{}% +% \else +% \addpenalty\@secpenalty\addvspace\@tempskipa +% \fi + \ifnum \GAL@b@ = \z@ + \addpenalty\@secpenalty\addvspace\@tempskipa + \fi + \@ifstar + {\@ssect{#3}{#4}{#5}{#6}}% + {\@dblarg{\@sect{#1}{#2}{#3}{#4}{#5}{#6}}}} + +\def\@xsect#1{% +%<*trace> + \showGALcmd{@xsect} +%</trace> + \@tempskipa #1\relax + \ifdim \@tempskipa>\z@ + \par \nobreak + \vskip \@tempskipa + \@afterheading + \else + \global\@noskipsectrue +% \@nobreakfalse +% \everypar{% +% \if@noskipsec +% \global\@noskipsecfalse +% {\setbox\z@\lastbox}% +% \clubpenalty\@M +% \begingroup \@svsechd \endgroup +% \unskip +% \@tempskipa #1\relax +% \hskip -\@tempskipa +% \else +% \clubpenalty \@clubpenalty +% \everypar{}% +% \fi}% + \setDGPVthing:nn i \@ne + \setGALbreak:n 2 + \setGALobject:n { \begingroup \@svsechd \endgroup + \unskip } +% obey stupid latex startsection interface with negative numbers ... + \@tempskipa #1\relax + \setDGPVdimension:nn h {-\@tempskipa} +% +% the noskipsec flag is probably needed in interaction with lists as +% long as this is only a partial conversion so i do set it (maybe not) +% + \everypar{% + \if@noskipsec + \global\@noskipsecfalse + \else + \everypar{}% + \fi}% + \fi + \ignorespaces} + +\gdef\@specialoutput{% +%<*trace> + \showGALcmd{@specialoutput} +%</trace> + \ifnum \outputpenalty>-\@Mii + \@doclearpage + \else + \GAL@ignore@next@galley + \ifnum \outputpenalty<-\@Miii + \ifnum \outputpenalty<-\@MM \deadcycles \z@ \fi + \global \setbox\@holdpg \vbox {\unvbox\@cclv}% + \else + \global \setbox\@holdpg \vbox{% + \unvbox\@holdpg + \unvbox\@cclv + \setbox\@tempboxa \lastbox + \unskip + }% + \@pagedp \dp\@holdpg + \@pageht \ht\@holdpg + \unvbox \@holdpg + \@next\@currbox\@currlist{% + \ifnum \count\@currbox>\z@ + \advance \@pageht \@pagedp + \ifvoid\footins \else + \advance \@pageht \ht\footins + \advance \@pageht \skip\footins + \advance \@pageht \dp\footins + \fi + \ifvbox \@kludgeins + \ifdim \wd\@kludgeins=\z@ + \advance \@pageht \ht\@kludgeins + \fi + \fi + \@reinserts + \@addtocurcol + \else + \@reinserts + \@addmarginpar + \fi + }\@latexbug +% +% with the same argument as before we can always add the penalty, right? +% + \ifnum \outputpenalty<\z@ +% \if@nobreak +% \nobreak +% \else + \addpenalty \interlinepenalty +% \fi + \fi + \fi + \fi +} + +\def \@addtocurcol {% +%<*trace> + \showGALcmd{@addtocurcol} +%</trace> + \@insertfalse + \@setfloattypecounts + \ifnum \@fpstype=8 + \else + \ifnum \@fpstype=24 + \else + \@flsettextmin + \advance \@textmin \@textfloatsheight + \@reqcolroom \@pageht + \ifdim \@textmin>\@reqcolroom + \@reqcolroom \@textmin + \fi + \advance \@reqcolroom \ht\@currbox + \ifdim \@colroom>\@reqcolroom + \@flsetnum \@colnum + \ifnum \@colnum>\z@ + \@bitor\@currtype\@deferlist + \if@test + \else + \@bitor\@currtype\@botlist + \if@test + \@addtobot + \else + \ifodd \count\@currbox + \advance \@reqcolroom \intextsep + \ifdim \@colroom>\@reqcolroom + \global \advance \@colnum \m@ne + \global \advance \@textfloatsheight \ht\@currbox + \global \advance \@textfloatsheight 2\intextsep + \@cons \@midlist \@currbox +% +% same argument as before (perhaps incorrect here?) +% +% \if@nobreak +% \nobreak +% \@nobreakfalse +% \everypar{}% +% \else + \addpenalty \interlinepenalty +% \fi +% +% at least it seems to me that we should not use \vskip here +% +% +% however we should then also have a way to trigger the use of the +% GAL structure without actually starting hmode (note done so all +% this is incorrect) +% + \vskip \intextsep + \box\@currbox +% +% and neither here ... +% + \penalty\interlinepenalty + \vskip\intextsep + \ifnum\outputpenalty <-\@Mii \vskip -\parskip\fi + \outputpenalty \z@ + \@inserttrue + \fi + \fi + \if@insert + \else + \@addtotoporbot + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \if@insert + \else + \@resethfps + \@cons\@deferlist\@currbox + \fi +} + +% and the whole item stuff is too complicated for me to really think +% about it tonight ... + +\def\@item[#1]{% +%<*trace> + \showGALcmd{@item} +%</trace> + \if@noparitem + \@donoparitem + \else + \if@inlabel + \indent \par + \fi + \ifhmode + \unskip\unskip \par + \fi + \if@newlist + \if@nobreak + \@nbitem + \else + \addpenalty\@beginparpenalty + \addvspace\@topsep + \addvspace{-\parskip}% + \fi + \else + \addpenalty\@itempenalty + \addvspace\itemsep + \fi + \global\@inlabeltrue + \fi + \everypar{% + \@minipagefalse + \global\@newlistfalse + \if@inlabel + \global\@inlabelfalse + {\setbox\z@\lastbox + \ifvoid\z@ + \kern-\itemindent + \fi}% + \box\@labels + \penalty\z@ + \fi + \if@nobreak + \@nobreakfalse + \clubpenalty \@M + \else + \clubpenalty \@clubpenalty + \everypar{}% + \fi}% + \if@noitemarg + \@noitemargfalse + \if@nmbrlist + \refstepcounter\@listctr + \fi + \fi + \sbox\@tempboxa{\makelabel{#1}}% + \global\setbox\@labels\hbox{% + \unhbox\@labels + \hskip \itemindent + \hskip -\labelwidth + \hskip -\labelsep + \ifdim \wd\@tempboxa >\labelwidth + \box\@tempboxa + \else + \hbox to\labelwidth {\unhbox\@tempboxa}% + \fi + \hskip \labelsep}% + \ignorespaces} + + +% \end{macrocode} +% +% +% \section{Fixing non-galley vboxes} +% +% \begin{macrocode} +\DeclareRobustCommand{\LaTeX}{L\kern-.36em% + {\sbox\z@ T% + \GAL@ignore@next@galley@vbox to\ht\z@{\hbox{\check@mathfonts + \fontsize\sf@size\z@ + \math@fontsfalse\selectfont + A}% + \vss}% + }% + \kern-.15em% + \TeX} +\DeclareTextCommandDefault{\textunderscore}{% + \leavevmode \kern.06em\GAL@ignore@next@galley@vbox{\hrule\@width.3em}} +\DeclareTextCommandDefault{\textvisiblespace}{% + \mbox{\kern.06em\vrule \@height.3ex}% + \GAL@ignore@next@galley@vbox{\hrule \@width.3em}% + \hbox{\vrule \@height.3ex}} +\gdef\showhyphens#1{% + \setbox0\vbox{% + \color@begingroup + \everypar{}% + \parfillskip\z@skip\hsize\maxdimen + \normalfont + \pretolerance\m@ne\tolerance\m@ne\hbadness\z@\showboxdepth\z@\ #1% + \color@endgroup}} +\catcode`\:=12 +\long\def\@imakepicbox(#1,#2)[#3]#4{% + \GAL@ignore@next@galley@vbox to#2\unitlength + {\let\mb@b\vss \let\mb@l\hss\let\mb@r\hss + \let\mb@t\vss + \@tfor\reserved@a :=#3\do{% + \if s\reserved@a + \let\mb@l\relax\let\mb@r\relax + \else + \expandafter\let\csname mb@\reserved@a\endcsname\relax + \fi}% + \mb@t + \hb@xt@ #1\unitlength{\mb@l #4\mb@r}% + \mb@b + \kern\z@}} +\catcode`\:=11 +\long\def\frame#1{% + \leavevmode + \hbox{% + \hskip-\@wholewidth + \GAL@ignore@next@galley@vbox{% + \vskip-\@wholewidth + \hrule \@height\@wholewidth + \hbox{% + \vrule\@width\@wholewidth + #1% + \vrule\@width\@wholewidth}% + \hrule\@height\@wholewidth + \vskip-\@wholewidth}% + \hskip-\@wholewidth}} +\def\@frameb@x#1{% + \@tempdima\fboxrule + \advance\@tempdima\fboxsep + \advance\@tempdima\dp\@tempboxa + \hbox{% + \lower\@tempdima\hbox{% + \GAL@ignore@next@galley@vbox{% + \hrule\@height\fboxrule + \hbox{% + \vrule\@width\fboxrule + #1% + \GAL@ignore@next@galley@vbox{% + \vskip\fboxsep + \box\@tempboxa + \vskip\fboxsep}% + #1% + \vrule\@width\fboxrule}% + \hrule\@height\fboxrule}% + }% + }% +} +\typeout{****~ Careful:~ there~ is~ another~ rewrite~ for~ iiiparbox~ in~ coffins!} + +\long\def\@iiiparbox#1#2[#3]#4#5{% + \leavevmode + \@pboxswfalse + \setlength\@tempdima{#4}% + \@begin@tempboxa\vbox{\hsize\@tempdima\@parboxrestore#5\@@par}% + \ifx\relax#2\else + \setlength\@tempdimb{#2}% + \def\@parboxto{to\@tempdimb}% + \fi + \GAL@ignore@next@galley + \if#1b\vbox + \else\if #1t\vtop + \else\ifmmode\vcenter + \else\@pboxswtrue $\vcenter + \fi\fi\fi + \@parboxto{\let\hss\vss\let\unhbox\unvbox + \csname bm@#3\endcsname}% + \if@pboxsw \m@th$\fi + \@end@tempboxa} +\def\@iiiminipage#1#2[#3]#4{% + \leavevmode + \@pboxswfalse + \setlength\@tempdima{#4}% + \def\@mpargs{{#1}{#2}[#3]{#4}}% + \setbox\@tempboxa\vbox\bgroup + \color@begingroup + \hsize\@tempdima + \textwidth\hsize \columnwidth\hsize + \@parboxrestore + \def\@mpfn{mpfootnote}\def\thempfn{\thempfootnote}\c@mpfootnote\z@ + \let\@footnotetext\@mpfootnotetext + \let\@listdepth\@mplistdepth \@mplistdepth\z@ + \@minipagerestore + \@setminipage} +\long\def\@mpfootnotetext#1{% + \global\setbox\@mpfootins\vbox{% + \unvbox\@mpfootins + \reset@font\footnotesize + \hsize\columnwidth + \@parboxrestore + \protected@edef\@currentlabel + {\csname p@mpfootnote\endcsname\@thefnmark}% + \color@begingroup + \@makefntext{% + \rule\z@\footnotesep\ignorespaces#1\@finalstrut\strutbox}% + \color@endgroup}} +\def\@array[#1]#2{% + \GAL@ignore@next@galley + \if #1t\vtop \else \if#1b\vbox \else \vcenter \fi\fi + \bgroup + \setbox\@arstrutbox\hbox{% + \vrule \@height\arraystretch\ht\strutbox + \@depth\arraystretch \dp\strutbox + \@width\z@}% + \@mkpream{#2}% + \edef\@preamble{% + \ialign \noexpand\@halignto + \bgroup \@arstrut \@preamble \tabskip\z@skip \cr}% + \let\@startpbox\@@startpbox \let\@endpbox\@@endpbox + \let\tabularnewline\\% +% +% we can't allow uncontrolled changes of \par +% +%%%% \let\par\@empty + \let\@sharp##% + \set@typeset@protect + \lineskip\z@skip\baselineskip\z@skip + \ifhmode \@preamerr\z@ \@@par\fi + \@preamble} +\gdef\@shortstack[#1]{% + \leavevmode + \GAL@ignore@next@galley@vbox\bgroup + \baselineskip-\p@\lineskip 3\p@ + \let\mb@l\hss\let\mb@r\hss + \expandafter\let\csname mb@#1\endcsname\relax + \let\\\@stackcr + \@ishortstack} +\gdef\@ishortstack#1{\ialign{\mb@l {##}\unskip\mb@r\cr #1\crcr}\egroup} +\gdef\@stackcr{\@ifstar\@ixstackcr\@ixstackcr} +\gdef\@ixstackcr{\@ifnextchar[\@istackcr{\cr\ignorespaces}} +\gdef\@istackcr[#1]{\cr\noalign{\vskip #1}\ignorespaces} +\newif\if@negarg +\gdef\line(#1,#2)#3{\@xarg #1\relax \@yarg #2\relax + \@linelen #3\unitlength + \ifdim\@linelen<\z@\@badlinearg\else + \ifnum\@xarg =\z@ \@vline + \else \ifnum\@yarg =\z@ \@hline \else \@sline\fi + \fi + \fi} +\gdef\@sline{% + \ifnum\@xarg<\z@ \@negargtrue \@xarg -\@xarg \@yyarg -\@yarg + \else \@negargfalse \@yyarg \@yarg \fi +\ifnum \@yyarg >\z@ \@tempcnta\@yyarg \else \@tempcnta -\@yyarg \fi +\ifnum\@tempcnta>6 \@badlinearg\@tempcnta\z@ \fi +\ifnum\@xarg>6 \@badlinearg\@xarg \@ne \fi +\setbox\@linechar\hbox{\@linefnt\@getlinechar(\@xarg,\@yyarg)}% +\ifnum \@yarg >\z@ \let\@upordown\raise \@clnht\z@ + \else\let\@upordown\lower \@clnht \ht\@linechar\fi +\@clnwd \wd\@linechar +\if@negarg + \hskip -\wd\@linechar \def\reserved@a{\hskip -2\wd\@linechar}% +\else + \let\reserved@a\relax +\fi +\@whiledim \@clnwd <\@linelen \do + {\@upordown\@clnht\copy\@linechar + \reserved@a + \advance\@clnht \ht\@linechar + \advance\@clnwd \wd\@linechar}% +\advance\@clnht -\ht\@linechar +\advance\@clnwd -\wd\@linechar +\@tempdima\@linelen\advance\@tempdima -\@clnwd +\@tempdimb\@tempdima\advance\@tempdimb -\wd\@linechar +\if@negarg \hskip -\@tempdimb \else \hskip \@tempdimb \fi +\multiply\@tempdima \@m +\@tempcnta \@tempdima +\@tempdima \wd\@linechar \divide\@tempcnta \@tempdima +\@tempdima \ht\@linechar \multiply\@tempdima \@tempcnta +\divide\@tempdima \@m +\advance\@clnht \@tempdima +\ifdim \@linelen <\wd\@linechar + \hskip \wd\@linechar + \@picture@warn + \else\@upordown\@clnht\copy\@linechar\fi} +\gdef\@hline{\ifnum \@xarg <\z@ \hskip -\@linelen \fi +\vrule \@height \@halfwidth \@depth \@halfwidth \@width \@linelen +\ifnum \@xarg <\z@ \hskip -\@linelen \fi} +\gdef\@getlinechar(#1,#2){\@tempcnta#1\relax\multiply\@tempcnta 8% + \advance\@tempcnta -9\ifnum #2>\z@ \advance\@tempcnta #2\relax\else + \advance\@tempcnta -#2\relax\advance\@tempcnta 64 \fi + \char\@tempcnta} +\gdef\vector(#1,#2)#3{\@xarg #1\relax \@yarg #2\relax + \@tempcnta \ifnum\@xarg<\z@ -\@xarg\else\@xarg\fi + \ifnum\@tempcnta<5\relax + \@linelen #3\unitlength + \ifdim\@linelen<\z@\@badlinearg\else + \ifnum\@xarg =\z@ \@vvector + \else \ifnum\@yarg =\z@ \@hvector \else \@svector\fi + \fi + \fi + \else\@badlinearg\fi} +\gdef\@hvector{\@hline\hb@xt@\z@{\@linefnt + \ifnum \@xarg <\z@ \@getlarrow(1,0)\hss\else + \hss\@getrarrow(1,0)\fi}} +\gdef\@vvector{\ifnum \@yarg <\z@ \@downvector \else \@upvector \fi} +\gdef\@svector{\@sline + \@tempcnta\@yarg \ifnum\@tempcnta <\z@ \@tempcnta -\@tempcnta\fi + \ifnum\@tempcnta <5% + \hskip -\wd\@linechar + \@upordown\@clnht \hbox{\@linefnt \if@negarg + \@getlarrow(\@xarg,\@yyarg)\else \@getrarrow(\@xarg,\@yyarg)\fi}% + \else\@badlinearg\fi} +\gdef\@getlarrow(#1,#2){\ifnum #2=\z@ \@tempcnta'33 \else + \@tempcnta #1\relax\multiply\@tempcnta \sixt@@n \advance\@tempcnta + -9 \@tempcntb #2\relax\multiply\@tempcntb \tw@ + \ifnum \@tempcntb >\z@ \advance\@tempcnta \@tempcntb + \else\advance\@tempcnta -\@tempcntb\advance\@tempcnta 64 + \fi\fi\char\@tempcnta} +\gdef\@getrarrow(#1,#2){\@tempcntb #2\relax +\ifnum\@tempcntb <\z@ \@tempcntb -\@tempcntb\relax\fi +\ifcase \@tempcntb\relax \@tempcnta'55 \or +\ifnum #1<\thr@@ \@tempcnta #1\relax\multiply\@tempcnta +24\advance\@tempcnta -6 \else \ifnum #1=\thr@@ \@tempcnta 49 +\else\@tempcnta 58 \fi\fi\or +\ifnum #1<\thr@@ \@tempcnta=#1\relax\multiply\@tempcnta +24\advance\@tempcnta -\thr@@ \else \@tempcnta 51 \fi\or +\@tempcnta #1\relax\multiply\@tempcnta +\sixt@@n \advance\@tempcnta -\tw@ \else +\@tempcnta #1\relax\multiply\@tempcnta +\sixt@@n \advance\@tempcnta 7 \fi\ifnum #2<\z@ \advance\@tempcnta 64 \fi +\char\@tempcnta} +\gdef\@vline{\ifnum \@yarg <\z@ \@downline \else \@upline\fi} +\gdef\@upline{% + \hb@xt@\z@{\hskip -\@halfwidth \vrule \@width \@wholewidth + \@height \@linelen \@depth \z@\hss}} +\gdef\@downline{% + \hb@xt@\z@{\hskip -\@halfwidth \vrule \@width \@wholewidth + \@height \z@ \@depth \@linelen \hss}} +\gdef\@upvector{\@upline\setbox\@tempboxa\hbox{\@linefnt\char'66}\raise + \@linelen \hb@xt@\z@{\lower \ht\@tempboxa\box\@tempboxa\hss}} +\gdef\@downvector{\@downline\lower \@linelen + \hb@xt@\z@{\@linefnt\char'77\hss}} +\gdef\dashbox#1(#2,#3){\leavevmode\hb@xt@\z@{\baselineskip \z@skip +\lineskip \z@skip +\@dashdim #2\unitlength +\@dashcnt \@dashdim \advance\@dashcnt 200 +\@dashdim #1\unitlength\divide\@dashcnt \@dashdim +\ifodd\@dashcnt\@dashdim \z@ +\advance\@dashcnt \@ne \divide\@dashcnt \tw@ +\else \divide\@dashdim \tw@ \divide\@dashcnt \tw@ +\advance\@dashcnt \m@ne +\setbox\@dashbox \hbox{\vrule \@height \@halfwidth \@depth \@halfwidth +\@width \@dashdim}\put(0,0){\copy\@dashbox}% +\put(0,#3){\copy\@dashbox}% +\put(#2,0){\hskip-\@dashdim\copy\@dashbox}% +\put(#2,#3){\hskip-\@dashdim\box\@dashbox}% +\multiply\@dashdim \thr@@ +\fi +\setbox\@dashbox \hbox{\vrule \@height \@halfwidth \@depth \@halfwidth +\@width #1\unitlength\hskip #1\unitlength}\@tempcnta\z@ +\put(0,0){\hskip\@dashdim \@whilenum \@tempcnta <\@dashcnt +\do{\copy\@dashbox\advance\@tempcnta \@ne }}\@tempcnta\z@ +\put(0,#3){\hskip\@dashdim \@whilenum \@tempcnta <\@dashcnt +\do{\copy\@dashbox\advance\@tempcnta \@ne }}% +\@dashdim #3\unitlength +\@dashcnt \@dashdim \advance\@dashcnt 200 +\@dashdim #1\unitlength\divide\@dashcnt \@dashdim +\ifodd\@dashcnt \@dashdim \z@ +\advance\@dashcnt \@ne \divide\@dashcnt \tw@ +\else +\divide\@dashdim \tw@ \divide\@dashcnt \tw@ +\advance\@dashcnt \m@ne +\setbox\@dashbox\hbox{\hskip -\@halfwidth +\vrule \@width \@wholewidth +\@height \@dashdim}\put(0,0){\copy\@dashbox}% +\put(#2,0){\copy\@dashbox}% +\put(0,#3){\lower\@dashdim\copy\@dashbox}% +\put(#2,#3){\lower\@dashdim\copy\@dashbox}% +\multiply\@dashdim \thr@@ +\fi +\setbox\@dashbox\hbox{\vrule \@width \@wholewidth +\@height #1\unitlength}\@tempcnta\z@ +\put(0,0){\hskip -\@halfwidth \GAL@ignore@next@galley@vbox{\@whilenum \@tempcnta <\@dashcnt +\do{\vskip #1\unitlength\copy\@dashbox\advance\@tempcnta \@ne }% +\vskip\@dashdim}}\@tempcnta\z@ +\put(#2,0){\hskip -\@halfwidth \GAL@ignore@next@galley@vbox{\@whilenum \@tempcnta<\@dashcnt +\do{\vskip #1\unitlength\copy\@dashbox\advance\@tempcnta \@ne }% +\vskip\@dashdim}}}\@makepicbox(#2,#3)} +\gdef\@ovvert#1#2{\GAL@ignore@next@galley@vbox to\@ovyy{% + \if@ovb \@tempcntb \@tempcnta \advance \@tempcntb #1\relax + \kern -\@ovro \hbox{\char \@tempcntb}\nointerlineskip + \else \kern \@ovri \kern \@ovdy \fi + \leaders\vrule \@width \@wholewidth\vfil \nointerlineskip + \if@ovt \@tempcntb \@tempcnta \advance \@tempcntb #2\relax + \hbox{\char \@tempcntb}% + \else \kern \@ovdy \kern \@ovro \fi}} +\catcode`\:=12 +\def\@xfloat #1[#2]{% + \@nodocument + \def \@captype {#1}% + \def \@fps {#2}% + \@onelevel@sanitize \@fps + \def \reserved@b {!}% + \ifx \reserved@b \@fps + \@fpsadddefault + \else + \ifx \@fps \@empty + \@fpsadddefault + \fi + \fi + \ifhmode + \@bsphack + \@floatpenalty -\@Mii + \else + \@floatpenalty-\@Miii + \fi + \ifinner + \@parmoderr\@floatpenalty\z@ + \else + \@next\@currbox\@freelist + {% + \@tempcnta \sixt@@n + \expandafter \@tfor \expandafter \reserved@a + \expandafter :\expandafter =\@fps + \do + {% + \if \reserved@a h% + \ifodd \@tempcnta + \else + \advance \@tempcnta \@ne + \fi + \fi + \if \reserved@a t% + \@setfpsbit \tw@ + \fi + \if \reserved@a b% + \@setfpsbit 4% + \fi + \if \reserved@a p% + \@setfpsbit 8% + \fi + \if \reserved@a !% + \ifnum \@tempcnta>15 + \advance\@tempcnta -\sixt@@n\relax + \fi + \fi + }% + \@tempcntb \csname ftype@\@captype \endcsname + \multiply \@tempcntb \@xxxii + \advance \@tempcnta \@tempcntb + \global \count\@currbox \@tempcnta + }% + \@fltovf + \fi + \global \setbox\@currbox + \color@vbox + \normalcolor + \vbox \bgroup + \hsize\columnwidth + \@parboxrestore + \@floatboxreset +} +\catcode`\:=11 +\def\end@float{% + \@endfloatbox + \ifnum\@floatpenalty <\z@ + \@largefloatcheck + \@cons\@currlist\@currbox + \ifnum\@floatpenalty <-\@Mii + \penalty -\@Miv + \@tempdima\prevdepth + \GAL@ignore@next@galley@vbox{}% + \prevdepth\@tempdima + \penalty\@floatpenalty + \else + \vadjust{\penalty -\@Miv \GAL@ignore@next@galley@vbox{}\penalty\@floatpenalty}\@Esphack + \fi + \fi +} +\def \@xympar{% + \ifnum\@floatpenalty <\z@\@cons\@currlist\@marbox\fi + \setbox\@tempboxa + \color@vbox + \vbox \bgroup + \end@float + \@ignorefalse + \@esphack +} +\def \AtBeginDvi #1{% + \global \setbox \@begindvibox + \vbox{\unvbox \@begindvibox #1}% +} +\def\clearpage{% + \ifvmode + \ifnum \@dbltopnum =\m@ne + \ifdim \pagetotal <\topskip + \hbox{}% + \fi + \fi + \fi + \newpage + \write\m@ne{}% + \GAL@ignore@next@galley@vbox{}% + \penalty -\@Mi +} +\def \@emptycol {\GAL@ignore@next@galley@vbox{}\penalty -\@M} +\long\def \@topnewpage [#1]{% + \@nodocument + \@next\@currbox\@freelist{}{}% + \global \setbox\@currbox + \color@vbox + \normalcolor + \vbox {% + \hsize\textwidth + \@parboxrestore + \col@number \@ne + #1% + \vskip -\dbltextfloatsep + }% + \color@endbox + \ifdim \ht\@currbox>\textheight + \ht\@currbox \textheight + \fi + \global \count\@currbox \tw@ + \@tempdima -\ht\@currbox + \advance \@tempdima -\dbltextfloatsep + \global \advance \@colht \@tempdima + \ifx \@dbltoplist \@empty + \else + \@latexerr{Float(s) lost}\@ehb + \let \@dbltoplist \@empty + \fi + \@cons \@dbltoplist \@currbox + \global \@dbltopnum \m@ne + \ifdim \@colht<2.5\baselineskip + \@latex@warning@no@line {Optional argument of \noexpand\twocolumn + too tall on page \thepage}% + \@emptycol + \if@firstcolumn + \else + \@emptycol + \fi + \else + \global \vsize \@colht + \global \@colroom \@colht + \@floatplacement + \fi +} +\gdef\@specialoutput{% + \ifnum \outputpenalty>-\@Mii + \@doclearpage + \else + \ifnum \outputpenalty<-\@Miii + \ifnum \outputpenalty<-\@MM \deadcycles \z@ \fi + \global \setbox\@holdpg \vbox {\unvbox\@cclv}% + \else + \global \setbox\@holdpg \vbox{% + \unvbox\@holdpg + \unvbox\@cclv + \setbox\@tempboxa \lastbox + \unskip + }% + \@pagedp \dp\@holdpg + \@pageht \ht\@holdpg + \unvbox \@holdpg + \@next\@currbox\@currlist{% + \ifnum \count\@currbox>\z@ + \advance \@pageht \@pagedp + \ifvoid\footins \else + \advance \@pageht \ht\footins + \advance \@pageht \skip\footins + \advance \@pageht \dp\footins + \fi + \ifvbox \@kludgeins + \ifdim \wd\@kludgeins=\z@ + \advance \@pageht \ht\@kludgeins + \fi + \fi + \@reinserts + \@addtocurcol + \else + \@reinserts + \@addmarginpar + \fi + }\@latexbug + \ifnum \outputpenalty<\z@ + \if@nobreak + \nobreak + \else + \addpenalty \interlinepenalty + \fi + \fi + \fi + \fi +} +\def \@doclearpage {% + \ifvoid\footins + \setbox\@tempboxa\vsplit\@cclv to\z@ \unvbox\@tempboxa + \setbox\@tempboxa\box\@cclv + \xdef\@deferlist{\@toplist\@botlist\@deferlist}% + \global \let \@toplist \@empty + \global \let \@botlist \@empty + \global \@colroom \@colht + \ifx \@currlist\@empty + \else + \@latexerr{Float(s) lost}\@ehb + \global \let \@currlist \@empty + \fi + \@makefcolumn\@deferlist + \@whilesw\if@fcolmade \fi{\@opcol\@makefcolumn\@deferlist}% + \if@twocolumn + \if@firstcolumn + \xdef\@dbldeferlist{\@dbltoplist\@dbldeferlist}% + \global \let \@dbltoplist \@empty + \global \@colht \textheight + \begingroup + \@dblfloatplacement + \@makefcolumn\@dbldeferlist + \@whilesw\if@fcolmade \fi{\@outputpage + \@makefcolumn\@dbldeferlist}% + \endgroup + \else + \GAL@ignore@next@galley@vbox{}\clearpage + \fi + \fi + \else + \setbox\@cclv\vbox{\box\@cclv\vfil}% + \@makecol\@opcol + \clearpage + \fi +} +\gdef \@makecol {% + \ifvoid\footins + \setbox\@outputbox \box\@cclv + \else + \setbox\@outputbox \vbox {% + \boxmaxdepth \@maxdepth + \@tempdima\dp\@cclv + \unvbox \@cclv + \vskip-\@tempdima + \vskip \skip\footins + \color@begingroup + \normalcolor + \footnoterule + \unvbox \footins + \color@endgroup + }% + \fi + \xdef\@freelist{\@freelist\@midlist}% + \global \let \@midlist \@empty + \@combinefloats + \ifvbox\@kludgeins + \@makespecialcolbox + \else + \setbox\@outputbox \vbox to\@colht {% + \@texttop + \dimen@ \dp\@outputbox + \unvbox \@outputbox + \vskip -\dimen@ + \@textbottom + }% + \fi + \global \maxdepth \@maxdepth +} +\gdef \@makespecialcolbox {% + \setbox\@outputbox \vbox {% + \@texttop + \dimen@ \dp\@outputbox + \unvbox\@outputbox + \vskip-\dimen@ + }% + \@tempdima \@colht + \ifdim \wd\@kludgeins>\z@ + \advance \@tempdima -\ht\@outputbox + \advance \@tempdima \pageshrink + \setbox\@outputbox \vbox to \@colht {% + \unvbox\@outputbox + \vskip \@tempdima + \@textbottom + }% + \else + \advance \@tempdima -\ht\@kludgeins + \setbox \@outputbox \vbox to \@colht {% + \GAL@ignore@next@galley@vbox to \@tempdima {% + \unvbox\@outputbox + \@textbottom}% + \vss}% + \fi + {\setbox \@tempboxa \box \@kludgeins}% +} +\def\@outputpage{% +\begingroup % the \endgroup is put in by \aftergroup + \@resetactivechars + \@parboxrestore + \let \protect \noexpand % <- this moved after parboxrestore!!!! + \shipout \vbox{% + \set@typeset@protect + \aftergroup \endgroup + \aftergroup \set@typeset@protect + % correct? or just restore by ending + % the group? + \if@specialpage + \global\@specialpagefalse\@nameuse{ps@\@specialstyle}% + \fi + \if@twoside + \ifodd\count\z@ \let\@thehead\@oddhead \let\@thefoot\@oddfoot + \let\@themargin\oddsidemargin + \else \let\@thehead\@evenhead + \let\@thefoot\@evenfoot \let\@themargin\evensidemargin + \fi + \fi + \reset@font + \normalsize + \normalsfcodes + \let\label\@gobble + \let\index\@gobble + \let\glossary\@gobble + \baselineskip\z@skip \lineskip\z@skip \lineskiplimit\z@ + \@begindvi + \vskip \topmargin + \moveright\@themargin \vbox {% + \setbox\@tempboxa \vbox to\headheight{% + \vfil + \color@hbox + \normalcolor + \hb@xt@\textwidth{\@thehead}% + \color@endbox + }% %% 22 Feb 87 + \dp\@tempboxa \z@ + \box\@tempboxa + \vskip \headsep + \box\@outputbox + \baselineskip \footskip + \color@hbox + \normalcolor + \hb@xt@\textwidth{\@thefoot}% + \color@endbox + }% + }% + \global \@colht \textheight + \stepcounter{page}% + \let\firstmark\botmark +} +\def \@cflt{% + \let \@elt \@comflelt + \setbox\@tempboxa \vbox{}% + \@toplist + \setbox\@outputbox \vbox{% + \boxmaxdepth \maxdepth + \unvbox\@tempboxa + \vskip -\floatsep + \topfigrule + \vskip \textfloatsep + \unvbox\@outputbox + }% + \let\@elt\relax + \xdef\@freelist{\@freelist\@toplist}% + \global\let\@toplist\@empty +} +\def\@comflelt#1{\setbox\@tempboxa + \vbox{\unvbox\@tempboxa\box #1\vskip\floatsep}} +\def \@combinedblfloats{% + \ifx \@dbltoplist \@empty + \else + \setbox\@tempboxa \vbox{}% + \let \@elt \@comdblflelt + \@dbltoplist + \let \@elt \relax + \xdef \@freelist {\@freelist\@dbltoplist}% + \global\let \@dbltoplist \@empty + \setbox\@outputbox \vbox to\textheight + {%\boxmaxdepth\maxdepth %% probably not needed, CAR + \unvbox\@tempboxa\vskip-\dblfloatsep + \ifnum \@dbltopnum>\m@ne + \dblfigrule + \fi + \vskip \dbltextfloatsep + \box\@outputbox + }% + \fi +} +\def\@vtryfc #1{% + \global\setbox\@outputbox\vbox{}% + \let\@elt\@wtryfc + \@flsucceed + \global\setbox\@outputbox \vbox to\@colht{% + \vskip \@fptop + \vskip -\@fpsep + \unvbox \@outputbox + \vskip \@fpbot}% + \let\@elt\relax + \xdef #1{\@failedlist\@flfail}% + \xdef\@freelist{\@freelist\@flsucceed}} +\def\@wtryfc #1{% + \global\setbox\@outputbox\vbox{% + \unvbox\@outputbox + \vskip\@fpsep + \box #1}} +\def\@addmarginpar{\@next\@marbox\@currlist{\@cons\@freelist\@marbox + \@cons\@freelist\@currbox}\@latexbug\@tempcnta\@ne + \if@twocolumn + \if@firstcolumn \@tempcnta\m@ne \fi + \else + \if@mparswitch + \ifodd\c@page \else\@tempcnta\m@ne \fi + \fi + \if@reversemargin \@tempcnta -\@tempcnta \fi + \fi + \ifnum\@tempcnta <\z@ \global\setbox\@marbox\box\@currbox \fi + \@tempdima\@mparbottom + \advance\@tempdima -\@pageht + \advance\@tempdima\ht\@marbox + \ifdim\@tempdima >\z@ + \@latex@warning@no@line {Marginpar on page \thepage\space moved}% + \else + \@tempdima\z@ + \fi + \global\@mparbottom\@pageht + \global\advance\@mparbottom\@tempdima + \global\advance\@mparbottom\dp\@marbox + \global\advance\@mparbottom\marginparpush + \advance\@tempdima -\ht\@marbox + \global\setbox \@marbox + \vbox {\vskip \@tempdima + \box \@marbox}% + \global \ht\@marbox \z@ + \global \dp\@marbox \z@ + \kern -\@pagedp + \nointerlineskip + \hb@xt@\columnwidth + {\ifnum \@tempcnta >\z@ + \hskip\columnwidth \hskip\marginparsep + \else + \hskip -\marginparsep \hskip -\marginparwidth + \fi + \box\@marbox \hss}% + \nointerlineskip + \hbox{\vrule \@height\z@ \@width\z@ \@depth\@pagedp}} +\def\@outputdblcol{% + \if@firstcolumn + \global \@firstcolumnfalse + \global \setbox\@leftcolumn \box\@outputbox + \else + \global \@firstcolumntrue + \setbox\@outputbox \vbox {% + \hb@xt@\textwidth {% + \hb@xt@\columnwidth {% + \box\@leftcolumn \hss}% + \hfil + \vrule \@width\columnseprule + \hfil + \hb@xt@\columnwidth {% + \box\@outputbox \hss}% + }% + }% + \@combinedblfloats + \@outputpage + \begingroup + \@dblfloatplacement + \@startdblcolumn + \@whilesw\if@fcolmade \fi + {\@outputpage + \@startdblcolumn}% + \endgroup + \fi +} + + + +% \end{macrocode} +% +% \begin{macrocode} +\catcode`\:=12\relax +\endinput +% \end{macrocode} +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% +% \Finale +% diff --git a/Master/texmf-dist/source/latex3/galley/galley2.ins b/Master/texmf-dist/source/latex3/galley/galley2.ins new file mode 100644 index 00000000000..f44ac61196b --- /dev/null +++ b/Master/texmf-dist/source/latex3/galley/galley2.ins @@ -0,0 +1,14 @@ +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble + +\endpreamble + +\generate{% + \file{galley2.sty}{\from{galley2.dtx}{package,trace}} + \file{xhj.sty}{\from{xhj.dtx}{package,trace}} + } + +\endbatchfile diff --git a/Master/texmf-dist/source/latex3/galley/xhj.dtx b/Master/texmf-dist/source/latex3/galley/xhj.dtx new file mode 100644 index 00000000000..56f245782c9 --- /dev/null +++ b/Master/texmf-dist/source/latex3/galley/xhj.dtx @@ -0,0 +1,1924 @@ +% \iffalse +%% +%% $Header: /usr3/users/latex3/design/consolidation/CURRENT/RCS/xhj.dtx,v 1.8 2000/01/14 15:24:24 latex3 Exp $ +%% +%% (C) Copyright 1999-2000 Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%% This module only works in conjunction with the galley2 module. +%% +%<*dtx> + \ProvidesFile{xhj.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{xhj} +%<driver>\ProvidesFile{xhj.drv} +% \fi +% \ProvidesFile{xhj.dtx} + [2000/01/14 v0.3c hyphenation & justification] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} +%\usepackage{xlists-samples} +%\makeatletter \let\GAL@typeout\@gobble \let\GAL@show@datastructure\@gobble +% \usepackage{ldcdoc} + +\newcommand\LaTeXplus{\LaTeXe$*$} + +\newcommand\DelayEvaluation{\texttt{\textbackslash DelayEvalution} + \ignorespaces} +\newcommand\fontwordspace{\texttt{\textbackslash fontwordspace}} +\newcommand\fontextraspace{\texttt{\textbackslash fontextraspace}} + + +% next three definitions are big hacks to run the file +% without the above packages +% +\newcommand\NoValue{\texttt{\textbackslash NoValue}} + +\makeatletter +\newenvironment{TemplateInterfaceDescription}[1] + {\subsection{The Template Type `#1'}% + \begingroup + \@beginparpenalty\@M + \description + \def\TemplateArgument##1##2{\item[Arg: ##1]##2\par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics:}}% + } + {\par\bigskip} + +\newenvironment{TemplateDescription}[2] + {\subsection{The Template `#2' (type #1)}% + \subsubsection*{Attributes:}% + \begingroup + \@beginparpenalty\@M + \description + \def\TemplateKey##1##2##3##4{\item[##1 (##2)]##3% + \ifx\TemplateKey##4\TemplateKey\else +% \hskip0ptplus3em\penalty-500\hskip 0pt plus 1filll Default:~##4% + \hfill\penalty500\hbox{}\hfill Default:~##4% + \nobreak\hskip-\parfillskip\hskip0pt\relax + \fi + \par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics \& Comments:}}% + } + {\par\bigskip} + +\newenvironment{InstanceDescription}[4][xxxxxxxxxxxxxxx] + {\subsubsection{The Instance `#3' (template #2/#4)}% + \subsubsection*{Attribute values:}% + \begingroup + \@beginparpenalty\@M + \def\InstanceKey##1##2{\>\textbf{##1}\>##2\\}% + \def\InstanceSemantics{\endtabbing\endgroup + \vskip-30pt\vskip0pt + \subsubsection*{Layout description \& Comments:}}% + \tabbing + xxxx\=#1\=\kill + } + {\par\bigskip} + +\makeatother + +\newcommand\key[1]{\textbf{#1}} + + \begin{document} + \DocInput{xhj.dtx} + \end{document} +%</driver> +% \fi +% +% \CheckSum{298} +% +% \newcommand\subsubsubsection{\paragraph} +% +% \GetFileInfo{xhj.dtx} +% +% \title{The \textsf{h\&j} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{FMi} +% \date{\filedate} +% \maketitle +% +% \tableofcontents +% +% \bigskip +% +% \begin{abstract} +% This module contains basic templates for interfacing with the +% galley mechanism as set up by the module +% \texttt{galley2}. These templates are intended for class +% designers and are mostly usable out of the box (i.e., this is one +% of the modules where providing a suitable number of default +% instances is probably sensible since they would cover 98\% of all +% usage. In contrast the \texttt{galley2} module contains only +% low-level interfaces for +% direct manipulation of the galley mechanism which are geared +% towards package writers having special needs which are not +% fulfilled by the templates in this module. +% \end{abstract} +% +% +% +% +% \section{Introduction} +% +% In \LaTeXplus{} terminology a galley is a rectangular area which +% receives text and other material filling it from +% top.\footnote{The predominant direction depends on the writing +% system and with extensions to \TeX{} such as Omega there are +% possibilities to define galleys with a different filling direction.} +% The vertically extend of a galley is normally not restricted +% (there are exceptions); instead certain chunks are taken off the top +% of an +% already partially filled galley to form columns or similar areas +% on a page. This process is typically asynchronous but there are ways +% to control or change its behavior. +% +% Examples for galleys are `the main galley', where the continuous +% document data gets formatted into and from which columns and pages are +% constructed, and `vbox galley's, such as the body of a minipage +% environment or the body of a float (in \LaTeXe only---the new float +% mechanism for \LaTeXplus{} will employ horizontally oriented float +% bodies). The latter galleys are typically not being split after +% formatting though there can be exceptions. +% +% Low-level interfaces for setting up such galleys and the way objects +% are formatted into them are provided by the module +% \texttt{galley2}. +% +% \subsection{Formatting layers} +% +% The present module is mainly concerned with the +% formatting of text in such galleys. +% The galley mechanism provides interfaces at four different layers +% some of which can be manipulated through the templates provided by +% this module. +% +% \subsubsection{Outer galley dimensions} +% +% In the bottom layer the external dimensions of a galley are +% fixed. In most cases only the horizontal dimension is defined while +% the vertical dimension (i.e., the filling direction) remains +% unspecified. These dimensions are fixed when initiating a new galley, +% using low-level functions, and are not modifiable. The horizontal +% overall width of the current galley is available for inspection in +% the register |\hsize|.\footnote{This is going to change once there +% is a final concept for handling this part of the interface, e.g., +% the relation of \texttt{\textbackslash hsize}, +% \texttt{\textbackslash columnwidth}, and \texttt{\textbackslash +% textwidth}. The latter are actually parameters of the text-page and +% should probably not be handled as it is done in \LaTeXe{}, i.e., by +% also using \texttt{\textbackslash columnwidth} as a measure for the +% current galley width. Perhaps one should introduce a +% \texttt{\textbackslash galleywidth} parameter instead of using +% \texttt{\textbackslash hsize}.} +% There are no templates that only set variable of this layer, though +% higher level +% templates (e.g., a template for providing minipage functionality) +% will of course address this part of the galley mechanism. +% +% +% \subsubsection{Inner galley dimensions} +% +% The second layer defines the inner horizontal galley dimensions of +% the galley, i.e., the measure used for paragraph text and its +% positioning within the galley. The current measure of the galley is +% available for inspection in the register |\linewidth| and the +% indentation from the left outer margin is available in the register +% |\@totalleftmargin|.\footnote{The two registers are already +% available in \LaTeXe{} and their names have been retained to make +% it easier to use a mixture of old and new code. However at some +% point the interface should be made more uniform by either providing +% two user accessible or two user inaccessible names.} +% +% This layer can (and should) be manipulated by higher-level templates +% through template instances of the type `measure'. These templates +% make long-term changes. +% +% +% +% +% \subsubsection{Paragraph shapes} +% +% The third layer defines the paragraph shape within the measure as +% provided by the second layer. In the absence of any specification +% for that layer the paragraph shape used will be that of a +% rectangular area of the width of the current measure. +% +% For this layer we are restricted by the mechanisms offered by +% \TeX{}. This means that it is possible to define particular +% paragraph shapes such as cutouts only from the top of a paragraph +% but not relative to its bottom. +% +% This layer can (and should) be manipulated by higher-level templates +% through template instances of the type `pshape'. Templates in this +% layer typically make short-term changes only (i.e. applicable only +% to the upcoming paragraph), however templates for long-term changes +% are also permissable though none are provided right now. +% +% A future implementation of the \texttt{galley2} module is probably +% going to support pshapes spanning several paragraphs, however at the +% moment pshapes apply per paragraph only. +% +% +% \subsubsection{Text formatting within the paragraph shape} +% +% The forth (and currently final) layer deals with the paragraph +% formatting aspects such as hyphenation and justification (h\&j which +% gave the current module its name). +% +% There are several template types in this layer: `hj' is a type that +% sets all aspects of h\&j in a single template whereas the types +% `justification', `linebreak', and `hyphenation' deal with individual +% aspects. +% +% \subsection{Open issues} +% +% Several but right now most of them are discussed when describing the +% interfaces in more details below. +% +% \begin{itemize} +% \item +% The model attempts a proper separation between paragraph shapes +% (layer three) and justification (part of layer four). However, due +% to the way \TeX{} works certain paragraph shapes can only be +% accomplished by using the parameters that are normally reserved +% for justification (an example would be the famous shape used by +% |\@dottedcontentsline|, i.e., a rectangular shape with the first +% line sticking out to the left and the last line sticking out to +% the right). How to integrate such shapes on layer three needs some +% more thought. +% \item +% What does the argument to the `measure' type really signal? Always +% a relative value (to current |\@totalleftmargin|), always an +% absolute value, or a value depending on what the template makes +% out of it? Perhaps this is not that important as one can't expect +% any such document supplied value be correct for different +% designs---or is this the wrong idea? At the moment I make +% it always be a relative change to |\@totalleftmargin| independent +% of the type of template being used. +% \end{itemize} +% +% +% \section{Interfaces} +% +% \begin{TemplateInterfaceDescription}{measure} +% +% \TemplateArgument{1} +% {Indentation of the left margin overwriting the default change +% or \NoValue{} in which case the value from the template +% is used. If provide the value is \emph{always} interpreted as +% being relative to the current indentation in the galley.} +% +% \TemplateSemantics +% This template type defines the basic measure of the galley, +% i.e., the width of the lines (|\linewidth|) and their +% indentation from the left (|\@totalleftmargin|). +% +% Each template of this type has to set the above parameters +% locally to their correct value.\footnote{That part of the +% implementation in \texttt{galley2.dtx} probably needs changing.} +% +% The templates can (and in most cases do) refer to an +% external\footnote{Again that is something which may not survive +% for long. It might very well be the case that all these +% parameters need to be added to the main galley data structures.} +% parameter holding the overall nominal width of the current +% galley (|\hsize|). However it is perfectly admissible that the +% template parameters are set in a way that |\@totalleftmargin| + +% |\linewidth| exceeds this nominal width (the galley mechanism +% provides low-level calls that allow for this without producing +% an error. This way paragraphs in a galley may stick out on +% either side if desired. +% +% One could think of making also the right margin being user +% over-writable or providing something like a boolean to modify the +% meaning of the template argument---suggestions/applications +% needed.\footnote{Think!} +% +% Templates of this type make long-term changes, i.e., their +% settings remain until the next occurence of an instance of this +% type or until the galley ends or its previous settings are +% restored. As remarked in the introduction +% there is a need for saving and restoring the settings of this +% particular part of the mechanism individually. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{measure}{relative} +% +% \TemplateKey{leftmargin}{l} +% {Additional indentation on the left for all lines} +% {none} +% +% \TemplateKey{rightmargin}{l} +% {Additional indentation on the right for all lines} +% {none} +% +% \TemplateSemantics +% This is the main template needed for defining vertically oriented +% lists and the like (at least if they are supposed to allow for +% nesting). +% +% \end{TemplateDescription} +% +% +% +% \begin{TemplateDescription}{measure}{absolute} +% +% \TemplateKey{leftmargin}{l} +% {Indentation on the left for all lines} +% {none} +% +% \TemplateKey{rightmargin}{l} +% {Indentation on the right for all lines measured from the +% nominal width of the galley (i.e., \texttt{\textbackslash +% hsize})} +% {none} +% +% \TemplateSemantics +% This template can be used in cases where one wishes to ignore +% any already existing indentations. Whether or not this has real +% applications remains to be seen. +% +% \end{TemplateDescription} +% +% +% +% +% +% \begin{TemplateInterfaceDescription}{pshape} +% +% \TemplateArgument{none} +% {---} +% +% \TemplateSemantics +% Templates of this type define the shape of the paragraph within +% the given measure of the galley, e.g., whether it has some +% special form such as a cutout one or the other side. +% +% Typically they define a shape only for the next paragraph, +% however templates that provide long term changes are also allowed. +% +% Since such special forms often require that all lines of a +% paragraph are kept together on a page these templates typically +% also define whether or not pages breaks within a paragraph are +% allowed. +% +% An interesting question is whether or not such templates should +% set (or inhibit) paragraph indentations via a template key. After +% all with cutouts on the top left such indentations are usually +% not desired.\footnote{Right now only justification templates set +% indentation but perhaps they should not, or both should, or what?} +% +% \end{TemplateInterfaceDescription} +% +% +% +% \begin{TemplateDescription}{pshape}{cutout} +% +% \TemplateKey{no-page-break-boolean}{s} +% {If true the upcoming paragraph will not be broken across a +% page. If false the breakability of the upcoming paragraph +% depends on other elements in the galley, i.e., it might still +% be forbidden to break.} +% {false} +% +% \TemplateKey{left-side-boolean}{s} +% {If true, the cutout will appear on the left otherwise it will +% appear on the right.} +% {true} +% +% \TemplateKey{normal-lines-num}{c} +% {Number of lines before the cutoff starts.} +% {0} +% +% \TemplateKey{parshape-list}{f0} +% {Comma separated list of dimensions denoting the horizontal +% size of the cutout for successive lines. If the paragraph +% contains more lines than the sum of \key{normal-lines-num} and +% the number of elements in this list then the remaining lines +% are all normal lines (i.e., cutout width 0pt) again.} +% {none} +% +% \TemplateSemantics +% This template is used to define a fixed cutout on one or the +% other side of a paragraph. It applies to the next paragraph +% only. +% +% The \key{normal-lines-num} is for convenience +% only. Alternatively one could prepend a suitable number of +% `\texttt{0pt,}'s to \key{parshape-list}. +% +% \end{TemplateDescription} +% +% +% \begin{InstanceDescription}[\textbf{no-page-break-boolean}xx] +% {pshape}{staggered}{cutout} +% +% \InstanceKey{no-page-break-boolean}{true} +% +% \InstanceKey{left-side-boolean}{true} +% +% \InstanceKey{normal-lines-num}{1} +% +% \InstanceKey{parshape-list}{20pt,40pt,60pt} +% +% \InstanceSemantics +% This instance will indent each line by an additional 20pt (up to +% the fourth line). A possible application would be a heading text +% (with a maximum number of four lines). +% This should then perhaps be combined with a special justification +% instance which does ragged right except for the last line which is +% set to full measure. +% +% \end{InstanceDescription} +% +% +% \begin{InstanceDescription}[\textbf{no-page-break-boolean}xx] +% {pshape}{ltriangle}{cutout} +% +% \InstanceKey{no-page-break-boolean}{true} +% +% \InstanceKey{left-side-boolean}{true} +% +% \InstanceKey{normal-lines-num}{0} +% +% \InstanceKey{parshape-list}{60pt,40pt,20pt} +% +% \InstanceSemantics +% This instance will produce a triangle cutout on the left upper +% corner of a paragraph. Could, for example, used together with an +% unusual heading layout~\ldots +% +% \end{InstanceDescription} +% +% +% \begin{InstanceDescription}[\textbf{no-page-break-boolean}xx] +% {pshape}{rectangle}{cutout} +% +% \InstanceKey{no-page-break-boolean}{false} +% +% \InstanceKey{left-side-boolean}{true} +% +% \InstanceKey{normal-lines-num}{0} +% +% \InstanceKey{parshape-list}{} +% +% \InstanceSemantics +% This instance can be used when a pshape is required but one just +% wants a standard regular paragraph area.\footnote{Using the cutoff +% template for this is overkill; at some point in the future this +% instance should be reimplemented.} +% +% \end{InstanceDescription} +% +% +% +% +% \begin{TemplateInterfaceDescription}{justification} +% +% \TemplateArgument{none} +% {---} +% +% \TemplateSemantics +% Templates of this type define how a paragraph text is formatted +% within the boundaries of a general paragraph shape (as defined +% through a measure (and perhaps additionally a pshape) +% template). More exactly they define whether or +% not the text should be justified at both sides or only at one +% side and in the latter case how much raggedness is desired, +% etc. See the instance examples for more details. +% +% The \key{linefillskip} in the templates below is worth +% mentioning. It defines a stretchable space that is used by +% commands that end a line prematurely in the middle of a +% paragraph, e.g., |\\| or |\newline|. In most cases what is +% needed is to fill the line with white space in exactly the same +% way as \TeX's |\parfillskip| parameter works (which is also the +% reason for the chosen default). However, for special instances +% this is not appropriate. Important is that any template of this +% type provides this key or rather provides a mechanism to +% correctly feeds the underlying data structure. +% +% Originally there have been different template types for setting +% the paragraph specs for all following paragraphs and for only +% the next one but this was combined into a single type. Whether +% or not this is the right approach remains to be seen. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{justification}{std} +% +% \TemplateKey{startskip}{l} +% {Stretchable space added to the left of the first line in a +% paragraph (in addition to \key{leftskip}).} +% {0pt} +% +% \TemplateKey{leftskip}{l} +% {Stretchable space added to the left of every line in a +% paragraph.} +% {\texttt{\textbackslash leftskip}} +% +% \TemplateKey{rightskip}{l} +% {Stretchable space added to the right of every line in a +% paragraph.} +% {\texttt{\textbackslash rightskip}} +% +% \TemplateKey{parfillskip}{l} +% {Stretchable space added to the right of the last line in a +% paragraph (in addition to \key{rightskip}).} +% {\texttt{\textbackslash parfillskip}} +% +% \TemplateKey{spaceskip}{l} +% {Stretchable space to use between words if non-zero. Otherwise +% size for space between words is taken from the current font +% metrics.} +% {\texttt{\textbackslash spaceskip}} +% +% \TemplateKey{xspaceskip}{l} +% {Extra space to use after periods etc.~(in certain situations)} +% {\texttt{\textbackslash xspaceskip}} +% +% \TemplateKey{linefillskip}{l} +% {Space to add at the point where some command requests a +% ``carriage-return line-feed'' in the middle of a paragraph, +% e.g., the \LaTeX{} command \texttt{\textbackslash newline}.} +% {value of \key{parfillskip}} +% +% \TemplateKey{parindent}{l} +% {Non-stretchable space to be added at the beginning of a +% paragraph.} +% {\texttt{\textbackslash parindent}} +% +% \TemplateSemantics +% +% This template sets the paragraph justification for all following +% paragraph (within the normal scope, i.e., until the end of the +% galley or a new specification). +% +% The key names for this template are derived from the original +% \TeX{} primitives whenever applicable. Perhaps this is a bad +% idea as \key{startskip} and \key{parfillskip} do not go well +% together. +% +% The defaults for most keys are actually the command names of the +% original \TeX{} primitives. The intention is that something like +% \key{parindent} could be externally provided by setting +% |\parindent| for all instances which do not explicitly set it to +% some value (e.g., to 0pt in instances where paragraph +% indentation is not really appropriate). Whether this is a good +% idea remains to be seen, this probably need some radically +% different default concept. +% +% \end{TemplateDescription} +% +% +% +% +% \begin{InstanceDescription}{justification}{default}{std} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{0pt plus 1fil} +% +% \InstanceSemantics +% +% This instance is slightly special as it is internally called +% whenever a new galley is instantiated, e.g., in a minipage. Thus +% it must be defined by class. The setting above is the same as for +% the adjust instance, but of course a class might wish to change +% this, e.g., if the desired layout requires ragged right setting by +% default. +% +% \end{InstanceDescription} +% +% +% +% +% +% +% \begin{InstanceDescription}{justification}{adjust}{std} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{0pt plus 1fil} +% +% \InstanceSemantics +% +% This instance provides the standard justified paragraph setting, +% i.e., every line is justified at both sides and the final line +% is set flush left. Paragraph indentation is not set, i.e. will +% be whatever the value of |\parindent| is. +% +% \end{InstanceDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{adjust2}{std} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{20pt plus 1fil} +% +% \InstanceSemantics +% +% This is a variation of the previous instance: the difference is +% that the last line of a paragraph can never be completely +% filled. In some sense this defines a paragraph indent at the +% end. +% +% Further variations are possible, e.g., one can ensure that the +% last line always contains at least a certain amount of space. +% +% \end{InstanceDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{center}{std} +% +% \InstanceKey{parindent}{0pt} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{0pt} +% +% \InstanceSemantics +% +% This instance is an example of a layout where the paragraph +% indent is explicitly set to zero to ensure that all lines are +% properly centered. Of course even with centered lines somebody +% could think of having a paragraph indentation: if so define a +% variation of the this instance. +% +% \end{InstanceDescription} +% +% +% +% +% \begin{InstanceDescription}{justification}{centermiddle}{std} +% +% \InstanceKey{parindent}{0pt} +% +% \InstanceKey{startskip}{-36pt plus -1fill} +% +% \InstanceKey{leftskip}{36pt plus 1fill} +% +% \InstanceKey{rightskip}{36pt plus 1fill} +% +% \InstanceKey{parfillskip}{-36pt plus -1fill} +% +% \InstanceSemantics +% +% A specialized instance that sets the first line of the paragraph +% flush left, the last line flush right and the intermediate lines +% centered with at least one centimeter space at each +% side. Possible application could be two or three line headings. +% +% \end{InstanceDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{raggedright}{std} +% +% \InstanceKey{startskip}{0pt} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{\DelayEvaluation 0pt plus 2em} +% +% \InstanceKey{parfillskip}{0pt plus 1fil} +% +% \InstanceKey{spaceskip}{\DelayEvaluation \fontwordspace} +% +% \InstanceKey{xspaceskip}{\DelayEvaluation +% \fontwordspace + \fontextraspace} +% +% \InstanceSemantics +% +% This interesting instance defines a ragged right setting which +% allows for hyphenation in case the raggedness would otherwise be +% too extreme (2em in the current font are considered okay anything +% in addition will start making the line bad as far as \TeX's +% paragraph algorithm is concerned so \TeX{} will consider +% hyphenation in such cases. +% +% An unjustified setting should always contain identical word +% spaces. Since we restrict the stretchability at the right end (it is +% of the same strength as the default word space stretchability), we +% have to ensure that the word spaces to not stretch or shrink at +% all. This is achieved by forcing the \key{spaceskip} to the +% normal font word space (without any stretch). +% +% \end{InstanceDescription} +% +% +% +% +% +% +% \begin{InstanceDescription}{justification}{flushleft}{std} +% +% \InstanceKey{startskip}{0pt} +% +% \InstanceKey{leftskip}{0pt} +% +% \InstanceKey{rightskip}{0pt plus 1fill} +% +% \InstanceKey{parfillskip}{0pt plus 1fill} +% +% \InstanceSemantics +% +% In contrast to the previous instance, this instance allows for +% arbitrary short lines, i.e., a paragraph set using this instance +% will never get hyphenated unless it contains words longer than +% the line measure. +% +% As all the stretchable space will appear at the right margin +% there in no point in artifically modify the word spaces as they +% will be set at their natural size anyway. +% +% \end{InstanceDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{raggedleft}{std} +% +% \InstanceKey{startskip}{0pt} +% +% \InstanceKey{leftskip}{\DelayEvaluation 0pt plus 2em} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{0pt} +% +% \InstanceKey{spaceskip}{\DelayEvaluation \fontwordspace} +% +% \InstanceKey{xspaceskip}{\DelayEvaluation +% \fontwordspace + \fontextraspace} +% +% \InstanceSemantics +% +% This instance is the raggedleft counter part to the raggedright +% instance above. +% +% \end{InstanceDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{flushright}{std} +% +% \InstanceKey{startskip}{0pt} +% +% \InstanceKey{leftskip}{0pt plus 1fill} +% +% \InstanceKey{rightskip}{0pt} +% +% \InstanceKey{parfillskip}{0pt} +% +% \InstanceSemantics +% +% And here is the variation which is not using hyphenation unless +% there is absolutely no other alternative. +% +% \end{InstanceDescription} +% +% +% +% \begin{TemplateDescription}{justification}{single} +% +% \TemplateKey{startskip}{l} +% {Stretchable space added to the left of the first line in a +% paragraph (in addition to \key{leftskip}).} +% {0pt} +% +% \TemplateKey{leftskip}{l} +% {Stretchable space added to the left of every line in a +% paragraph.} +% {\texttt{\textbackslash leftskip}} +% +% \TemplateKey{rightskip}{l} +% {Stretchable space added to the right of every line in a +% paragraph.} +% {\texttt{\textbackslash rightskip}} +% +% \TemplateKey{parfillskip}{l} +% {Stretchable space added to the right of the last line in a +% paragraph (in addition to \key{rightskip}).} +% {\texttt{\textbackslash parfillskip}} +% +% \TemplateKey{spaceskip}{l} +% {Stretchable space to use between words if non-zero. Otherwise +% size for space between words is taken from the current font +% metrics.} +% {\texttt{\textbackslash spaceskip}} +% +% \TemplateKey{xspaceskip}{l} +% {Extra space to use after periods etc.~(in certain situations)} +% {\texttt{\textbackslash xspaceskip}} +% +% \TemplateKey{linefillskip}{l} +% {Space to add at the point where some command requests a +% ``carriage-return line-feed'' in the middle of a paragraph, +% e.g., the \LaTeX{} command \texttt{\textbackslash newline}.} +% {value of \key{parfillskip}} +% +% \TemplateKey{parindent}{l} +% {Non-stretchable space to be added at the beginning of a +% paragraph.} +% {\texttt{\textbackslash parindent}} +% +% \TemplateSemantics +% +% This template is exactly the same as the std one, except that it +% applies only to the next paragraph after which the previous +% setting will become active again. For an explanation of the keys +% see the std template description. +% +% It is not clear whether this approach makes much +% sense. See comments below. +% +% \end{TemplateDescription} +% +% +% +% +% +% \begin{InstanceDescription}{justification}{centerfirst}{single} +% +% \InstanceKey{startskip}{0pt plus 2fill} +% +% \InstanceKey{leftskip}{0pt plus -1fill} +% +% \InstanceKey{rightskip}{0pt plus 1fill} +% +% \InstanceKey{parfillskip}{0pt} +% +% \InstanceKey{linefillskip}{0pt} +% +% \InstanceSemantics +% +% This instance centers the first line of a paragraph and sets all +% remaining lines as a solid block (including the last line). This +% is a rather specialized justification method which relies on some +% peculiar features of the \TeX's internal handling of stretchable +% space. It is not possible to control the amount of white space on +% the first line (other than forcing it to be centered) with the +% controls available. Anything further needs manual intervention by +% the user. +% +% In a similar fashion centering of the last line could be achieved +% (by setting \key{parfillskip} rather than \key{startskip}. +% +% \end{InstanceDescription} +% +% +% +% +% +% +% +% \begin{TemplateDescription}{justification}{complex} +% +% \TemplateKey{first-para-justification-setup}{i} +% {Justification setup for the first paragraph of a sequence.} +% {none} +% +% \TemplateKey{other-para-justification-setup}{i} +% {Justification setup for the remaining paragraphs in the sequence} +% {none} +% +% \TemplateSemantics +% +% This template allows to specify a different justification setup +% for the first paragraph of a sequence and its remaining +% paragraphs. Due to the implementation it is currently required +% that the key \key{first-para-justification-setup} receives an +% instance defined through the template `single' or more exactly +% through a template that modifies the justification setup only for +% a single paragraph. Otherwise all paragraphs in the sequence will +% be formatted in the same way (i.e., the second key would have no +% effect). +% +% This is largely due to the fact that the implementation previously +% contained different template types for local and `global' changes +% to the justification.\footnote{Better concept needed! Perhaps the +% coding in galley2 needs changing in this area.} +% +% +% \end{TemplateDescription} +% +% +% +% +% \begin{InstanceDescription}[\textbf{other-para-justification-setup}xx] +% {justification}{centerfirst-adjust}{complex} +% +% \InstanceKey{first-para-justification-setup}{centerfirst} +% +% \InstanceKey{other-para-justification-setup}{adjust} +% +% \InstanceSemantics +% +% This instance is an example for a paragraph justification where +% the first and the remaining paragraphs are handled differently: +% the first paragraph will get a centered first line (with the +% remaining lines being set as a squared block and any additional +% paragraph will be justified. A common use for such a +% layout would be table captions. +% +% \end{InstanceDescription} +% +% +% +% +% +% +% +% +% +% +% \begin{TemplateInterfaceDescription}{hyphenation} +% +% \TemplateArgument{none} +% {---} +% +% \TemplateSemantics +% +% Templates of this type define whether or not hyphenation is +% attempted for upcoming paragraphs in the galley and if hyphenation +% is allowed whether it should be encouraged (to support better +% justification) or whether it should be only used if justification +% would get too bad without it.\footnote{There are a few conceptual +% questions: should templates of this type set anything like +% \key{hyphenpenalty} or would this be better handled in the +% linebreak template type and this template type only be used to set +% hyphenation on/off? In case of the latter is it needed as a +% separate type or should it be added to some other type?} +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{hyphenation}{TeX} +% +% \TemplateKey{uchyph}{c} +% {If positive allow hyphenation of words starting with an +% uppercase letter.} +% {1} +% +% \TemplateKey{hyphenpenalty}{c} +% {} +% {50} +% +% \TemplateKey{exhyphenpenalty}{c} +% {} +% {50} +% +% \TemplateKey{lefthyphenmin}{c} +% {} +% {leave unchanged} +% +% \TemplateKey{righthyphenmin}{c} +% {} +% {leave unchanged} +% +% \TemplateSemantics +% +% Keys are named like the \TeX{} primitives. As I remarked +% earlier, perhaps \key{hyphenpenalty} and \key{exhyphenpenalty} +% should be moved to the linebreak templates. +% +% Also an open question is the keys +% \key{left/righthyphenmin}. Their minimum values are actually a +% feature of the current language or more exactly a feature of the +% hyphenation patterns in force, but on the other hand one can +% increase their values without harm and especially by setting +% them to extremely high values one can disable hyphenation +% altogether. So how should this be handled? +% +% \end{TemplateDescription} +% +% +% +% \begin{TemplateDescription}{hyphenation}{std} +% +% \TemplateKey{hyphen-enable-boolean}{s} +% {If false disables hyphenation} +% {none} +% +% \TemplateKey{hyphen-uppercase-boolean}{s} +% {If positive allows hyphenation of words starting with an +% uppercase letter.} +% {none} +% +% \TemplateKey{hyphen-discourage-boolean}{s} +% {Sets penalties for breaking a line at a discretionary to a +% higher value. Only relevant if \key{hyphen-enable-boolean} is +% set to true.} +% {none} +% +% \TemplateKey{hyphen-encourage-boolean}{s} +% {Sets penalties for breaking a line at a discretionary to a +% higher value. Only relevant if \key{hyphen-enable-boolean} is +% set to true.} +% {none} +% +% \TemplateSemantics +% +% Better or worse than the TeX version? In any case it remains a +% question of whether the line breaking parts should be set in a +% template like this. +% +% \end{TemplateDescription} +% +% +% +% +% +% +% \begin{TemplateInterfaceDescription}{linebreak} +% +% \TemplateArgument{none} +% {---} +% +% \TemplateSemantics +% +% This template type determines the line breaking behavior of the +% \TeX{} machinery, with the exception of whether or not to +% hyphenate (certain) words. It could be considered to moved the +% parameters related to breaking up math formulas to a separate +% type. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{linebreak}{TeX} +% +% \TemplateKey{pretolerance}{c} +% {Maximum tolerance allowed for individual lines to break the +% paragraph without attempting hyphenation.} +% {100} +% +% \TemplateKey{tolerance}{c} +% {Maximum tolerance allowed for individual lines when breaking a +% paragraph while attempting hyphenation (if this limit can't be +% met \key{emergencystretch} comes into play.} +% {200} +% +% \TemplateKey{linepenalty}{c} +% {Extra penalty charged per line in the paragraph. By making +% this penalty higher \TeX{} will try harder to produce compact +% paragraphs.} +% {10} +% +% \TemplateKey{binoppenalty}{c} +% {Penalty charged if an inline math formula is broken at a +% binary operator.} +% {700} +% +% \TemplateKey{relpenalty}{c} +% {Penalty charged if an inline math formula is broken at a +% relational symbol.} +% {500} +% +% \TemplateKey{hbadness}{c} +% {Boundary that if exceeded will cause \TeX{} to report an +% underfull line.} +% {1000} +% +% \TemplateKey{adjdemerits}{c} +% {Extra demerit charge if two visually incompatible lines follow +% each other.} +% {10000} +% +% \TemplateKey{doublehyphendemerits}{c} +% {Extra demerit charge of two (or more) lines in succession end +% in a hyphen.} +% {10000} +% +% \TemplateKey{finalhyphendemerits}{c} +% {Extra demerit charge if the second last line is hyphenated.} +% {5000} +% +% \TemplateKey{hfuzz}{l} +% {Boundary below overfull lines are not reported.} +% {.1pt} +% +% \TemplateKey{emergencystretch}{l} +% {Complicated --- I write up the explanation at some other day :-)} +% {0pt} +% +% \TemplateSemantics +% Keys are named like the \TeX{} primitives. As I remarked +% earlier, perhaps \key{hyphenpenalty} and \key{exhyphenpenalty} +% from the hyphenation template +% should be moved to the linebreak templates. +% +% +% \end{TemplateDescription} +% +% +% +% +% +% +% \begin{TemplateInterfaceDescription}{hj} +% +% \TemplateArgument{none} +% {---} +% +% \TemplateSemantics +% Often certain combinations of justification, line breaking and +% hyphenation settings are used together. For those case it might +% be desirable to be able to identify these settings with a single +% name. The hj type provides for this. It is supposed to set the +% complete ``micro typography'' setting concerning paragraphs, +% i.e., everything that happens within the outer form as defined by +% the measure and/or pshape templates. +% +% Whether this template type is actually needed remains to be +% seen. Clearly everywhere where it gets applied one could apply +% individually templates of type justification, linebreak, and +% hyphenation. +% +% Right now the low-level galley interface uses an instance of this +% type (with the name ``default'') to initialize a new +% galley. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{hj}{std} +% +% \TemplateKey{justification-setup}{i} +% {Instance specifying the justification used.} +% {\texttt{default}} +% +% \TemplateKey{linebreak-setup}{i} +% {Instance specifying the line breaking parameters} +% {\texttt{default}} +% +% \TemplateKey{hyphenation-setup}{i} +% {Instance specifying the hyphenation parameter used.} +% {\texttt{default}} +% +% \TemplateSemantics +% This is the shortcut template as discussed before. One could +% think of other templates that do set the parameters using a large +% number keys (\TeX{} style, for example) --- whether this +% makes sense~\ldots +% +% \end{TemplateDescription} +% +% + +% \begin{InstanceDescription}[\textbf{justification-setup}xx] +% {hj}{default}{std} +% +% \InstanceKey{justification-setup}{default} +% +% \InstanceKey{linebreak-setup}{default} +% +% \InstanceKey{hyphenation-setup}{default} +% +% \InstanceSemantics +% +% This instance is used when initializing new galleys. It is in +% fact slightly faster to run |\UseInstance{hj}{default}| compared +% to three calls to |\UseInstance| for the individual template +% instances.\footnote{This is because we avoid the overhead of +% \texttt{\textbackslash UseInstance} (the keys of type \texttt{i} +% are optimized in this respect.} +% +% \end{InstanceDescription} +%% +% +% +% +% \StopEventually{} +% +% \section{Implementation} +% +% Set up certain defaults including to ignore white space +% within the body of this package. \LaTeXe{} release needs to be +% recent because of changing some bits of the |\parbox| handling below. +% \begin{macrocode} +%<*package> +\NeedsTeXFormat{LaTeX2e}[1998/12/01] +% \end{macrocode} +% +% \begin{macrocode} +\RequirePackage{template,xparse} +% \RequirePackage{galley2} % this is required but needs to + % be loaded afterwards !!!! +% \end{macrocode} +% +% The primitives of the galley mechanism currently have ``:'' in their +% names so\ldots +% \begin{macrocode} +\IgnoreWhiteSpace +\catcode`\:=11\relax +% \end{macrocode} +% +% +% \subsection{Using Font Dimensions} +% +% Some helper functions to access information in a tfm file. +% They do not really belong here but right now we don't have a place +% for them. +% \begin{macro}{\@usefontdimen} +% A shorthand: +% \begin{macrocode} +\def\@usefontdimen#1{\fontdimen#1\font} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\fontslant} +% \begin{macro}{\fontwordspace} +% \begin{macro}{\fontwordspacestretch} +% \begin{macro}{\fontwordspaceshrink} +% \begin{macro}{\fontex} +% \begin{macro}{\fontem} +% \begin{macro}{\fontextraspace} +% The following commands access dimension of the current font, +% e.g., |\fontwordspace| gives the width of a space between words +% in the current font. Typically these commands have to be used +% together with |\DelayEvaluation| so that they are applied at +% runtime rather than during the declaration of template +% instances. +% \begin{macrocode} +\def\fontslant {\@usefontdimen1} +\def\fontwordspace {\@usefontdimen2} +\def\fontwordspacestretch {\@usefontdimen3} +\def\fontwordspaceshrink {\@usefontdimen4} +\def\fontex {\@usefontdimen5} +\def\fontem {\@usefontdimen6} +\def\fontextraspace {\@usefontdimen7} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \subsection{Templates for the second layer} +% +% \subsubsection{The template type `measure'} +% +% The `measure' type takes one argument (left margin or +% |\NoValue|), see discussion above. +% \begin{macrocode} +\DeclareTemplateType{measure}{1} +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{measure}{absolute}{1}{ + leftmargin =l \leftmargin, + rightmargin =l \rightmargin, + }{ + \DoParameterAssignments +% \end{macrocode} +% +% User provided left margin is always relative to current +% indentation even if template does provide absolute values. +% \begin{macrocode} + \IfNoValueF{#1} { \setlength\leftmargin{ #1 + \@totalleftmargin } } + \setSGPVmeasure:nn \leftmargin {\hsize -\leftmargin -\rightmargin } +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{measure}{relative}{1}{ + leftmargin =l \leftmargin, + rightmargin =l \rightmargin, + }{ + \DoParameterAssignments + \IfNoValueF{#1} { \setlength\leftmargin{#1} } + \addSGPVmeasure:nn \leftmargin { -\leftmargin -\rightmargin } +} +% \end{macrocode} +% +% +% +% \subsection{Templates for the third layer} +% +% \subsubsection{The template type `pshape'} +% +% The template type `pshape' right now is mostly an interface to +% \TeX's |\parshape| primitive. This is probably going to be extended. +% +% \begin{macrocode} +\DeclareTemplateType{pshape}{0} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{pshape}{cutout}{0}{ + no-page-break-boolean =s {\setGALbreak:n {-3}}{}, + left-side-boolean =s {}{\let\shape@side\setGALrightparshape:nnn}, + normal-lines-num =C \pshape@normalines, + parshape-list =f0 \pshape@parshape, + }{ + \let\pshape@normalines\z@ + \let\shape@side\setGALleftparshape:nnn + \DoParameterAssignments + \shape@side \pshape@normalines \z@ \pshape@parshape + } +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{pshape}{staggered}{cutout}{ + no-page-break-boolean = true, + normal-lines-num = 1, + parshape-list = { 20pt, 40pt, 60pt }, +} +% \end{macrocode} +% +% +% +% \begin{macrocode} +\DeclareInstance{pshape}{ltriangle}{cutout}{ + no-page-break-boolean = true, + normal-lines-num = 0, + parshape-list = { 60pt, 40pt, 20pt }, +} +% \end{macrocode} +% +% The next instance provides a ``noop'' or ``regular'' pshape instance, +% i.e., one +% that can be applied when a template requests to set up a pshape but +% the standard rectangular is desired (of course using using the +% cutout template for this task is very very inefficient so at some +% point this should be done differently). +% +% \begin{macrocode} +\DeclareInstance{pshape}{rectangle}{cutout}{ + no-page-break-boolean = false, + normal-lines-num = 0, + parshape-list = { }, +} +% \end{macrocode} +% +% +% \subsection{Templates for the forth layer} +% +% \subsubsection{The template type `justification'} +% +% How we justify the text within the measure: +% \begin{macrocode} +\DeclareTemplateType{justification}{0} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{justification}{single}{0}{ + startskip =L \justification@a , + leftskip =L \justification@b , + rightskip =L \justification@c , + parfillskip =L \justification@d , + spaceskip =L \justification@e , + xspaceskip =L \justification@f , + linefillskip =L \justification@g , + parindent =L \justification@h , + }{ + \def\justification@a{\z@} + \def\justification@b{\leftskip} + \def\justification@c{\rightskip} + \def\justification@d{\parfillskip} + \def\justification@e{\spaceskip} + \def\justification@f{\xspaceskip} + \def\justification@g{\justification@d} + \def\justification@h{\parindent} +% + \DoParameterAssignments +% \end{macrocode} +% Next is a written out form of |\appendtoDGPVthing:nx| (more or less) +% \begin{macrocode} + \xdef \GAL@j@ + {{\justification@a} + {\justification@b} + {\justification@c} + {\justification@d} + {\justification@e} + {\justification@f} + {\justification@g} + {\justification@h} + } + \GAL@prepare@reassign:NN \GAL@j@ \GAL@j@s + } +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{justification}{std}{0}{ + startskip =L \justification@a , + leftskip =L \justification@b , + rightskip =L \justification@c , + parfillskip =L \justification@d , + spaceskip =L \justification@e , + xspaceskip =L \justification@f , + linefillskip =L \justification@g , + parindent =L \justification@h , + } + { + \def\justification@a{\z@} + \def\justification@b{\leftskip} + \def\justification@c{\rightskip} + \def\justification@d{\parfillskip} + \def\justification@e{\spaceskip} + \def\justification@f{\xspaceskip} + \def\justification@g{\justification@d} +% + \def\justification@h{\parindent} + \DoParameterAssignments + \edef \@tempa {\noexpand \setSGPVthing:nn j + {{\justification@a} + {\justification@b} + {\justification@c} + {\justification@d} + {\justification@e} + {\justification@f} + {\justification@g} + {\justification@h} + } + } + \@tempa +% \end{macrocode} +% \begin{macrocode} + \expandafter \setup@paragraph@justification \GAL@j@ +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{justification}{complex}{0}{ + first-para-justification-setup =i {justification} + \justification@first, + other-para-justification-setup =i {justification} + \justification@other, + } + { + \DoParameterAssignments +% long term changes first! + \justification@other + \justification@first + } +% \end{macrocode} +% +% +% +% And some instances for testing \ldots +% \begin{macrocode} +\DeclareInstance{justification}{adjust}{std} + {rightskip =0pt, + leftskip =0pt, + startskip =0pt, + parfillskip=\fill +} +% \end{macrocode} +% +% +% +% Another name for the above: +% \begin{macrocode} +\DeclareInstance{justification}{default}{std} + {rightskip =0pt, + leftskip =0pt, + startskip =0pt, + parfillskip=\fill +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{adjust2}{std} + {parindent = 0pt, + rightskip = 0pt, + leftskip = 0pt, + startskip = 0pt, + parfillskip= 20pt plus 1fil +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{center}{std} + {parindent =0pt, + rightskip =\fill, + leftskip =\fill, + startskip =0pt, + parfillskip=0pt +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{centermiddle}{std} + {parindent =0pt, + rightskip =36pt plus 1fill, + leftskip =36pt plus 1fill, + startskip =-36pt plus -1fill, + parfillskip=-36pt plus -1fill, + linefillskip= 0pt, +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{raggedright}{std} + {rightskip = \DelayEvaluation 0pt plus 2em, + leftskip = 0pt, + startskip = 0pt, + parfillskip= \fill, + spaceskip = \DelayEvaluation \fontwordspace, + xspaceskip = \DelayEvaluation \fontwordspace + \fontextraspace, +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{flushleft}{std} + {rightskip =\fill, + leftskip =0pt, + startskip =0pt, + parfillskip=\fill, +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{raggedleft}{std} + {leftskip = \DelayEvaluation 0pt plus 2em, + rightskip = 0pt, + startskip = 0pt, + parfillskip= 0pt, + spaceskip = \DelayEvaluation \fontwordspace, + xspaceskip = \DelayEvaluation \fontwordspace + \fontextraspace, +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{flushright}{std} + {leftskip = \fill, + rightskip = 0pt, + startskip = 0pt, + parfillskip= 0pt, +} +% \end{macrocode} +% +% +% \begin{macrocode} +% this does now work: +\DeclareInstance{justification}{centerfirst}{single} + {parindent = 0pt, + rightskip = \fill, + leftskip = -\fill, + parfillskip= 0pt, + startskip = 0pt plus 2fill, + linefillskip= 0pt, +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{justification}{centerfirst-adjust}{complex} + { first-para-justification-setup = centerfirst, + other-para-justification-setup = adjust + } +% \end{macrocode} +% +% +% +% \subsubsection{The template `linebreak'} +% +% How we attempt to break the paragraph into lines: +% \begin{macrocode} +\DeclareTemplateType{linebreak}{0} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{linebreak}{TeX}{0}{ + pretolerance =c [100] \pretolerance, + tolerance =c [200] \tolerance, + linepenalty =c [10] \linepenalty, + binoppenalty =c [700] \binoppenalty, + relpenalty =c [500] \relpenalty, + hbadness =c [1000] \hbadness, + adjdemerits =c [10000] \adjdemerits, + doublehyphendemerits =c [10000] \doublehyphendemerits, + finalhyphendemerits =c [5000] \finalhyphendemerits, +% + hfuzz =l [.1pt] \hfuzz, + emergencystretch =l [0pt] \emergencystretch, +% +} + {\DoParameterAssignments +%<*trace> + \GAL@typeout{Now~ changing~ linebreaking} +%</trace> + } +% \end{macrocode} +% +% +% +% +% +% \begin{macrocode} +\DeclareInstance{linebreak}{default}{TeX}{} +\DeclareInstance{linebreak}{fussy}{TeX}{} +\DeclareInstance{linebreak}{sloppy}{TeX} + { + tolerance = 9999, + hfuzz = .5pt, + emergencystretch = \DelayEvaluation 3em, + } +% \end{macrocode} +% +% +% \begin{macro}{\fussy} +% \begin{macro}{\sloppy} +% Two old friends from \LaTeX: +% \begin{macrocode} +\def\fussy {\UseInstance{linebreak}{fussy}} +\def\sloppy{\UseInstance{linebreak}{sloppy}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \subsubsection{The template type `hyphenation'} +% +% How do we handle the question of hyphenation: +% \begin{macrocode} +\DeclareTemplateType{hyphenation}{0} + +\DeclareTemplate{hyphenation}{TeX}{0}{ + uchyph =c [1] \uchyph, + hyphenpenalty =c [50] \hyphenpenalty, + exhyphenpenalty =c [50] \exhyphenpenalty, + lefthyphenmin =c \lefthyphenmin, + righthyphenmin =c \righthyphenmin, +} + {\DoParameterAssignments +%<*trace> + \GAL@typeout{Now~ changing~ hyphenation} +%</trace> + } +% \end{macrocode} +% +% +% +% +% +% \begin{macrocode} +\newcount\@@lefthyphenmin +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{hyphenation}{std}{0}{ + hyphen-enable-boolean =s {\ifnum\@@lefthyphenmin>\z@ + \lefthyphenmin\@@lefthyphenmin + \fi} + {\@@lefthyphenmin\lefthyphenmin + \lefthyphenmin\@M}, + hyphen-uppercase-boolean =s {\uchyph\@ne}{\uchyph\z@}, + hyphen-discourage-boolean=s {\hyphenpenalty\@highpenalty + \exhyphenpenalty\@highpenalty}{}, + hyphen-encourage-boolean =s {\hyphenpenalty\@lowpenalty + \exhyphenpenalty\@lowpenalty}{}, +} + {\DoParameterAssignments +%<*trace> + \GAL@typeout{Now~ changing~ hyphenation} +%</trace> + } +% \end{macrocode} +% +% +% +% +% +% \begin{macrocode} +\DeclareInstance{hyphenation}{default}{TeX} + {} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{hyphenation}{off}{std} + {hyphen-enable-boolean = false} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{hyphenation}{on}{std} + {hyphen-enable-boolean = true} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{hyphenation}{discourage}{std} + {hyphen-enable-boolean = true, + hyphen-discourage-boolean = true} +% +%\ShowInstance{hyphenation}{off} +%\ShowInstance{hyphenation}{discourage} +% \end{macrocode} +% +% +% +% \subsubsection{The template type `hj'} +% +% \begin{macrocode} +\DeclareTemplateType{hj}{0} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{hj}{std}{0}{ + justification-setup =i {justification} [default] \hj@justification, + linebreak-setup =i {linebreak} [default] \hj@linebreak, + hyphenation-setup =i {hyphenation} [default] \hj@hyphenation, +} + {\DoParameterAssignments + \hj@justification + \hj@linebreak + \hj@hyphenation + } +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{hj}{default}{std}{} +% \end{macrocode} +% +% +% \begin{macrocode} +%\ShowInstance{hj}{default} +% \end{macrocode} +% +% +% \begin{macrocode} +\catcode`\:=12\relax +\endinput +% \end{macrocode} +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% +% \Finale +% +% \endinput +% +% +% +% \subsection{The template `pagebreak'} +% +% +% +% The rest doesn't belong here but i've already set it up I have to +% keep it somewhere until work on the page builder actually +% starts---so why not in this place. +% +% \begin{TemplateInterfaceDescription}{pagebreak} +% +% \TemplateArgument{1} +% {none} +% +% \TemplateSemantics +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{pagebreak}{TeX} +% +% \TemplateKey{clubpenalty}{c} +% {} +% {150} +% +% \TemplateKey{widowpenalty}{c} +% {} +% {150} +% +% \TemplateKey{displaywidowpenalty}{c} +% {} +% {50} +% +% \TemplateKey{predisplaypenalty}{c} +% {} +% {10000} +% +% \TemplateKey{postdisplaypenalty}{c} +% {} +% {0} +% +% \TemplateKey{brokenpenalty}{c} +% {} +% {100} +% +% \TemplateKey{interlinepenalty}{c} +% {} +% {0} +% +% \TemplateKey{vbadness}{c} +% {} +% {1000} +% +% \TemplateKey{vfuzz}{l} +% {} +% {.1pt} +% +% \TemplateSemantics +% +% \end{TemplateDescription} +% +% +% +% +% \begin{macrocode} +\DeclareTemplateType{pagebreak}{0} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplate{pagebreak}{TeX}{0}{ + clubpenalty =c [150] \clubpenalty, + widowpenalty =c [150] \widowpenalty, + displaywidowpenalty =c [50] \displaywidowpenalty, + predisplaypenalty =c [10000] \predisplaypenalty, + postdisplaypenalty =c [0] \postdisplaypenalty, + brokenpenalty =c [100] \brokenpenalty, + interlinepenalty =c [0] \interlinepenalty, +% + vbadness =c [1000] \vbadness, + vfuzz =l [.1pt] \vfuzz, +} + {\DoParameterAssignments +%<*trace> + \GAL@typeout{Now~ changing~ pagebreaking} +%</trace> + } +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareInstance{pagebreak}{default}{TeX}{} +% \end{macrocode} +% +% +% +% +% +% +% +% +% \begin{TemplateInterfaceDescription}{} +% +% \TemplateArgument{1} +% {} +% +% \TemplateSemantics +% +% \end{TemplateInterfaceDescription} +% +% diff --git a/Master/texmf-dist/source/latex3/template/template.dtx b/Master/texmf-dist/source/latex3/template/template.dtx new file mode 100644 index 00000000000..286449af968 --- /dev/null +++ b/Master/texmf-dist/source/latex3/template/template.dtx @@ -0,0 +1,2053 @@ +% \iffalse +%% +%% (C) Copyright 1999 David Carlisle, Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{template.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{template} +%<driver>\ProvidesFile{template.drv} +% \fi +% \ProvidesFile{template.dtx} + [1999/09/28 v0.14 template parsing (DPC,FMi)] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} +\makeatletter + \newenvironment{decl}[1][]% + {\par\small\addvspace{4.5ex plus 1ex}% + \vskip -\parskip + \ifx\relax#1\relax + \def\@decl@date{}% + \else + \def\@decl@date{\NEWfeature{#1}}% + \fi + \noindent\hspace{-\leftmargini}% + \begin{tabular}{|l|}\hline\ignorespaces}% + {\\\hline\end{tabular}\nobreak\@decl@date\par\nobreak + \vspace{2.3ex}\vskip -\parskip\@afterheading} +\makeatother + + \begin{document} + \DocInput{template.dtx} + \end{document} +%</driver> +% \fi +% +% +% \CheckSum{864} +% +% \GetFileInfo{template.dtx} +% +% \title{The \textsf{template} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{DPC, FMi} +% \date{\filedate} +% \maketitle +% +% \changes{0.06}{1998/12/17}{generic functions reborn as templates} +% +% \tableofcontents +% +% \section{Introduction} +% A \emph{Template} is a named `function' that has a fixed number +% of \emph{mandatory arguments} and an additional set of \emph{keys} +% or `named attributes' that are set in a `key value list'. That is, +% a comma separated set of assignments of the form:\\ +% \meta{key$_1$} |=| \meta{value$_1$} |,| +% \meta{key$_2$} |=| \meta{value$_2$} \ldots +% +% More specific instances of the template may be declared by +% specifying settings of the parameters. The key value list is parsed +% at the time the instance is declared, and an `internal' set of +% parameter assignments is passed to the template code. It is normally +% not parsed at run-time, though it is possible to enforce this +% behaviour. +% +% Templates have a \emph{type} and a \emph{name}. Templates +% of the same type have the same argument and parameter +% structure. That is, templates of the same type are expected to be +% exchangeable semantically. (However, except for checking that +% templates of the same type always have the same number of arguments +% this is not enforced by the code.) +% +% A template type is declared via the |\DeclareTemplateType| +% declaration which takes two arguments: the name for the type and the +% number of arguments a template of this type requires. +% +% Templates are declared via the |\DeclareTemplate| +% command which takes five arguments +% \begin{itemize} +% \item The \emph{type} of the template (no |\|). +% \item The \emph{name} of the template (no |\|). +% \item The number of arguments for the template (same as on type +% declaration). +% \item A list declaring the keys accepted by the template, +% with information about the action to take when the key is specified +% with a value. +% \item The code for the template. This may be arbitrary \TeX\ +% code. At some point it should execute |\DoParameterAssignments| +% to run the parameter assigments. +% +% The mandatory arguments are accessed via |#1|, |#2|, \ldots +% \end{itemize} +% +% +% Each element of the key specification list is of the form: +% \begin{flushleft} +% \meta{key name} |=| +% \meta{key type} \meta{optional default} \meta{internal code} +% \end{flushleft} +% +% The \meta{key types} are essentially specified by giving a symbolic +% representation of the assignment function to be used by \TeX. +% +% Currently the possibilities are +% +% \begin{center}\catcode`|=12 +% \begin{tabular}{l|ll|l} +% key type& letter& internal code& argument form\\\hline +% Command & f\emph{n}&command name & command definition\\ +% name & n & command name & command definition\\ +% length & l & length register& calc length syntax\\ +% fake length & L & command name & calc length syntax\\ +% count & c & count register& calc count syntax\\ +% fake count & C & command name & calc count syntax\\ +% boolean & b & name of \verb|\newif| switch& true or false\\ +% switch & s & \marg{true code}\marg{false code}& true or false\\ +% instance& i\marg{type}& command name& instance of this \emph{type}\\ +% direct & x & Internal code& any\\ +% general & g & general code & any +% \end{tabular} +% \end{center} +% +% In addition, any of these types may be prefixed by |+| to +% denote a global assignment (described below). +% |f| takes a digit from 0--9 to denote the number of arguments. +% |n| is in fact the same as |f0|. When an instance is declared +% The value assigned to the key should be the definition of +% the command, using |#1|\ldots|#9| to denote the specified arguments. +% +% |c| takes an internal form a count register, +% not a \LaTeX\ counter name. +% +% For |f|, |n|, |l|, and |c|, the assignment is done twice, once +% at the time an instance is \emph{declared}. (This may involve +% using \textsf{calc} expresions. Then the `primitive assignment' +% of the value (not using calc) is copied to the internal parameter +% list, to be executed when an instance is run. Sometimes you need the +% expression to be evaluated at the time an instance is run rather +% than the time it is declared. For example it may be an expression +% involving some values that are not fixed throughout a document. +% In this case the instance declaration may give a value in the +% form |\DelayedEvaluation|\marg{calc expression}. In this case +% the value is not evaluated when the instance is declared, and +% instead the entire expression is copied to the `internal parameter +% list' and is evaluated whenever the instance is used. +% +% |L| and |C| take the same value types as |l| and |c| but the internal +% assignments are to macros not registers. +% +% Keys declared with |b| and |s| each take values either \emph{true} or +% \emph{false}. if the key zzz is declared with |b| then specifying +% |zzz=true| will essentially pass |\zzztrue| to the internal parameter +% list (although in fact |\zzztrue| need not be defined) . If instead +% zzz had been declared via |s|, then |zzz=true| would pass the tokens +% of the \marg{true code} to the internal parameter list. +% +% If a key is specified as |x|, then when used the \emph{internal code} +% will be copied to the internal parameter lists. This code may use |#1| +% to denote the value supplied to the key in the instance declaration. +% Note that this code is \emph{only} copied at the time the instance is +% declared. It is not executed at this time. It is executed when the +% instance is executed.\footnote{Despite the question of whether or +% not x and g are still necessary these days, they have the wrong +% `names' since x is the one that is not executed during delcaration +% while g is.} +% +% If a key is declared with |g| then the code is run at the time the +% instance is declared. By default \emph{nothing} is passed to the +% internal parameter list. This code may use |#1| to denote the +% value that will be supplied when an instance is declared. +% Any code that should be run when an instance is executed should +% be explicitly passed to the internal parameter list using +% |\addto@hook\TP@toks{|\ldots|}| +% +% A key declared with |i|\marg{type} takes as value the name of a +% declared instance of that type. The command token associated with +% the key will store a command essentially equivalent to a call +% to |\UseInstance|\marg{type}\marg{name}, but in a slightly optimised +% internal form. +% As an exception to this rule the replacement code may be of the form +% |\UseTemplate| followed by the key settings for the template +% but without the mandatory arguments. In this case the `inner' +% instance declaration is `pre compiled' and the token assigned to +% the store the value assigned to this key will execute an instance +% of the template directly, it will not re-parse the keyword settings +% each time the instance is used. +% +% \section{Commands} +% +% +% \subsection{Template declaration commands} +% +% \begin{decl} +% |\DeclareTemplateType| \marg{type}\marg{num} +% \end{decl} +% Declare a template type. +% +% \begin{decl} +% |\DeclareTemplate| +% \marg{type}\marg{tname}\marg{num}\marg{keyspec}\marg{code} +% \end{decl} +% Declare a template \meta{tname} of type \meta{type} with the set of +% keys as defined by \meta{keyspec}. From this template instances can +% be declared using |\DeclareInstance| At runtime such instances will run +% \meta{code} and expect \meta{num} mandatory arguments (same number +% for all templates of one type).\footnote{The \meta{num} argument is +% redundent as it can be deduced from the type. However, for practical +% reasons it seems better to keep that information with each +% individual template declaration.} +% +% \begin{decl} +% |\DeclareRestrictedTemplate| +% \marg{type}\marg{new-tname}\marg{old-tname}\marg{keyvals} +% \end{decl} +% Declare as new template \meta{new-tname} for type \meta{type} by +% taking template \meta{old-tname} as the basis and setting one or +% more of its keys to specific values. +% +% \begin{decl} +% |\DoParameterAssignments| +% \end{decl} +% The list of key value assignments made (and saved) during template +% declaration is evaluated at this point in the template code. +% +% +% \subsection{Instance declaration commands} +% +% \begin{decl} +% |\DeclareInstance| \marg{type}\marg{iname}\marg{tname}\marg{keyvals} +% \end{decl} +% Declare an instance of type \meta{type} named \meta{iname} build +% from using template \meta{tname} with key settings as given by +% \meta{keyvals}. +% +% \begin{decl} +% |\DeclareCollectionInstance| +% \marg{collection}\marg{type}\marg{iname}\marg{tname}\marg{keyvals} +% \end{decl} +% Same as |\DeclareInstance| except that this instance is only active +% when for the type \meta{type} the collection \meta{collection} was +% selected via |\UseCollection|. E.g., within the frontmatter one +% could make all headings behave differently by defining collection +% instances for template type `head'. +% +% \subsection{Key value commands} +% +% \begin{decl} +% |\DelayEvaluation|\marg{code} +% \end{decl} +% Used in the value spec for an instance to declare that the value +% \meta{code} should not be evaluated at declaration time but at +% run-time. Can also be used in the defaults for keys (given in square +% brackets) in the declaration of templates. +% +% \begin{decl} +% |\MultiSelection| \meta{counter} \marg{cases} \marg{else} +% \end{decl} +% Used in the value spec for an instance key to declare that the value of +% this key depends on the current setting of \meta{counter} at run-time. +% The \meta{cases} argument is a comma-separated list of ``values'', +% the \meta{else} argument a single ``value''. If at run-time +% \meta{counter} has the value $i$ then the $i$-th element of the +% \meta{cases} list is selected. If that does not exist the +% \meta{else} case is returned. +% +% +% \subsection{Processing commands} +% +% \begin{decl} +% |\UseTemplate| \marg{type}\marg{tname}\marg{keyval} +% \end{decl} +% Execute a template \meta{tname} of type \meta{type} at run-time +% using \meta{keyvals} as the value assignments for its keys. In this +% case the keys are evaluated at run-time thus this method is far +% slower than using a predeclared instance of this template (see +% below). This command can also appear as the value for a key of type +% `i' in which case the evaluation happens at declaration time of the +% template that contains this key! +% +% +% \begin{decl} +% |\UseInstance| \marg{type}\marg{iname} +% \end{decl} +% Run the instance \meta{iname} of template type \meta{type}. If a +% collection is in force see if there is a collection instance of name +% \meta{iname} and if so run that instead. +% +% \begin{decl} +% |\UseCollection| \marg{type}\marg{collection} +% \end{decl} +% Declare that from now on (normal scoping rules) the collection +% \meta{collection} for template type \meta{type} is in force. This +% means that a call to |\UseInstance| will first check if there is a +% collection instance defined, and if so use that instance, otherwise +% use the normal instance. +% +% +% \subsection{Test commands} +% +% \begin{decl} +% |\IfExistsInstanceTF| \marg{type}\marg{iname}\marg{true}\marg{false} +% \end{decl} +% Test if for template type \meta{type} an instance with name +% \meta{iname} exists. Select \meta{true} or \meta{false} code +% accordingly. +% +% +% +% \section{Examples of template key types} +% +% The general syntax for key specification in templates (fourth argument +% of the command |\DeclareTemplate|) is: +%\begin{flushleft} +%| {| \\ +%| | \meta{key-name$_1$} |=|\meta{key-type$_1$} +% \meta{optional-default$_1$} \meta{storage-bin$_1$}|,|\\ +%| | \meta{key-name$_2$} |=|\meta{key-type$_2$} +% \meta{optional-default$_2$} \meta{storage-bin$_2$}|,|\\ +%| ...|\\ +%| }| +%\end{flushleft} +% In this section we look at all possible key types and give examples +% for them. +% +% +% \subsection{Attributes that receive names as values} +% +% The type |n| expects to receive a \LaTeX{} name as a value. Used, +% for example, to specify the name of a \LaTeX{} counter to use. +%\begin{verbatim} +% heading-id =n \heading@id, +% counter-id =n [\DelayEvaluation{\heading@id}] \heading@counter, +%\end{verbatim} +% Notice the use of |\DelayEvaluation| in the default of +% |counter-id|. It is necessary to make the default the token +% |\heading@id| if we want to inherit the value from the |heading-id| +% key. Otherwise it gets value of |\heading@id| at the time the +% instance is declared. +% +% +% \subsection{Attributes that receive functions as values} +% +% +% The type |f|\meta{num} expects a function with \meta{num} arguments +% as a value. The arguments are denoted by |#1|, |#2|, etc. In most +% cases either |f0| (for declarations) or |f1| (to format one argument) are +% needed. +%\begin{verbatim} +% initial-font =f0 \initial@font, +% initial-format =f1 [#1] \initial@boxhandling, +%\end{verbatim} +% +% \subsection{Attributes that receive dimensions as values} +% +% As far as specifying instances the |l| and |L| type behave +% identically. They differ only in the type of internal storage-bin +% they need: |l| expects a length register while |L| expects an +% ordinary macro name and assigns its value via |\def|. +%\begin{verbatim} +% pre-sep =l \topsep, +% post-sep =L \botsep, +%\end{verbatim} +% +% +% +% \subsection{Attributes that receive integers as values} +% +% The |c| and |C| type receive integers as values. Again either of +% them can be transparently used. In case of |c| the +% \meta{storage-bin} has to be a \TeX{} count register not a \LaTeX{} +% counter name, i.e., set up via |\newcount|. (\LaTeX{} counters can +% be used as well if they are accessed via their internal name, i.e., +% via |\c@|\meta{\LaTeX-counter}) +%\begin{verbatim} +% pre-penalty =c \@beginparpenalty, +% penalty =C \hmaterial@penalty, +%\end{verbatim} +% +% +% +% \subsection{Attributes that receive template instances as values} +% +% The type |i|\marg{type} takes as value the name of a declared +% instance of that type. The \meta{storage-bin} associated with the +% key will store a command essentially equivalent to a call to +% |\UseInstance|\marg{type}\marg{name}, but in a slightly optimised +% internal form. +% +% As an exception to this rule the replacement code may be of the form +% |\UseTemplate| followed by the key settings for the template but +% without the mandatory arguments. In this case the `inner' instance +% declaration is `pre compiled' and the token assigned to the store +% the value assigned to this key will execute an instance of the +% template directly, it will not re-parse the keyword settings each +% time the instance is used. +%\begin{verbatim} +% justification-setup =i{justification} \list@justification, +%\end{verbatim} +% +% Usage within an instance declaration is either +%\begin{verbatim} +% justification-setup = raggedright, +%\end{verbatim} +% i.e., name of a declared instance or a call to |\UseTemplate| +%\begin{verbatim} +% justification-setup = \UseTemplate{justification}{TeX} +% { startskip = 0pt, ... }, +%\end{verbatim} +% +% +% +% \subsection{Attributes that receive true or false values} +% +% The type |s| expects the strings |true| or |false| as values. In +% this case the declaration has no \meta{storage-bin}. Instead the +% declaration consists of two brace groups containing code. Depending +% on the value one of the groups gets copied verbatim into the +% internal parameter list of the instance and gets executed at +% run-time at the point where |\DoParameterAssignments| is seen. +%\begin{verbatim} +% item-implicit-boolean =s +% { \def\item@implicit@code{\item\relax} }{}, +% numbered-boolean =b [true] @heading@nums, +%\end{verbatim} +% +% +% \subsection{Attributes that accept any value} +% +% The type |g| is a low-level specification which contains arbitrary +% code in place of the \meta{storage-bin}. This code is evaluated at +% declaration time of the instance and by default \emph{nothing} is +% passed to the internal parameter list (this has to happen explicitly +% from within the code). |#1| may be used to access the value +% specified. + +% The main purpose for this type is of historical nature (originally +% most of the other types have been implemented internally using |g|). +% +% The type |x| also requires code in place of the \meta{storage-bin}. +% However with this type all of the code is copied unevaluated to the +% internal parameter list. There are some applications for this type +% when implementing customisable defaults. However, it is likely that +% it will not survive a final release. +%\begin{verbatim} +% generic-key =g \typeout{#1}, +% extra-assigns =x \typeout{#1}, +%\end{verbatim} +% +% +% +% +% +% +% \section{A complete example} +% +% The following example shows a sketch of a template for typesetting +% captions to be used as part of a larger mechanism setting whole +% floats.\footnote{I made it up while I went along so if you spot the +% ``missing brace'' or some other blunder tell me, FMi.} +% +% We declare a template type \texttt{caption} then define an example +% template for that type and finally produce some instances from that. +% +% \subsection{Declaring the template type} +% +% To define the template type we first have to ask ourselves what +% information would be varying each time such a template is used? A +% potential answer could be the following: +% \begin{itemize} +% \item +% The float name, e.g., `Table' or `Fig.' etc. +% \item +% The float +% number e.g., `10' or `3--c' etc. +% \item +% The actual caption text as specified in the document. +% \end{itemize} +% Since the above items would be differed in each instantiation of +% such a template we would pass them as mandatory argument to the +% template. +% +% Are there others? Possibly. Here are two more that seem to be +% useful, at least in a number of cases: +% \begin{itemize} +% \item +% The text of the legend in document classes that distinguish +% between caption text (heading to the figure/table) and legend +% (explanatory material) +% \item +% Measure to which the caption should be typeset. +% \end{itemize} +% The last one of these might need some extra explanation. Suppose a +% design requires that the caption width is decided depending on the +% width of the table of figure, e.g., the caption is supposed to +% typeset below some illustration and should not be wider than that +% illustration, or the caption is typeset aside to the illustration +% using the remaining space. In that case the process that formats the +% whole float needs to communicate with the current template to pass +% that (varying) information along. Of course, that could happen by +% using global variables, e.g., the outer process sets the measure as +% desired before calling the caption formatting template. What makes +% more sense is likely to be a matter of taste but it also has to do +% with the precise semantics of the template type. Staying with our +% example: if the the semantics of the template type \texttt{caption} +% is supposed to produce a formatted box (in \TeX{} terms) then we +% should pass the measure as an argument if we ever intend to allow +% for variations. If on the other hand the semantics are to format a +% certain set of text into the current galley (which has measure of +% its own) then a measure argument would not belong to this template +% type. +% +% Are there other variations sensible? Yes, for example, instead of +% passing a fixed string like ``Fig.'' as the first argument one could +% pass an abstract float type identifier and let the template worry to +% deduce from that information what fixed string to produce. +% +% Another question: why should we pass the fixed text (or an abstract +% identifier from which it can be deduced) and the number as separate +% arguments to the template instead of passing a combined string (like +% it is done in the |\@makecaption| command of \LaTeXe{})? Answer: +% because this allows to build templates that can individually +% manipulate both bits of information, e.g., to format the number in a +% different font, etc. +% +% So what are the conclusions of this discussion? Defining the +% semantics of a template type is difficult and often needs several +% trials to come up with something that is covering the anticipated +% use. There is clearly not a cardinal way for defining template +% types; how the overall separation into smaller units is done is +% partly a matter of taste and partly a matter of the major layout +% characteristics that one tries to support. +% +% Returning to our example: let's assume we settle for the first four +% arguments, i.e., the calling template is responsible for setting the +% measure for the caption text if necessary. +% +% What we also have to do is to define (at least for ourselves) what +% data the arguments accept and what their semantics are. An informal +% summary of that could be the following: +% \begin{center} +% \begin{tabular}{rrl} +% \textit{Arg} & \textit{Data Type} & \textit{Description} \\[3pt] +% 1 & text & fixed float description +% \\ +% 2 & text/|\NoValue| & float number +% \\ +% 3 & text & caption text +% \\ +% 4 & text/|\NoValue| & legend text +% \\ +% \end{tabular} +% \end{center} +% The second and the fourth argument are allowed to be missing (i.e., +% can get |\NoValue| passed as a value). Note that the empty string in +% case of a text argument is different from |\NoValue|. +% +% We further declare that it is permissible for a template of this +% type to ignore the information provided by all arguments except 3, +% i.e., the caption text. +% +% Finally the result of the template formatting should is to typeset +% text into a current galley (paragraph mode in \LaTeX{} lingua). +% +% All the above is semantic information that (at least right now) is +% not being enforced by declaring a template type (except for the +% number of arguments) but each template of a certain type is supposed +% to conform to this specification nonetheless.\footnote{To make this +% even clearer we are thinking of extending the template type +% declaration with another argument in which one has to formally or +% informally (?) specifies information like the one in the table +% above.} +% +% This finally leads to the following declaration: +%\begin{verbatim} +%\DeclareTemplateType{caption}{4} +%\end{verbatim} +% +% \subsection{Defining a first template} +% +% We start by defining a simple template of type \texttt{caption} +% which roughly formats a caption like those being presented in +% \LaTeXe{}'s article class, i.e., the caption is typeset as a +% paragraph if it is longer than a single line, otherwise it is +% centered. The legend even if present is ignored. Above and below we +% give the designer the possibility to add some space. +% +% In fact the examples is more or less identical in code to +% |\@makecaption| except that if the second argument (i.e., the +% number) is |\NoValue| it and its preceding space\footnote{For those +% who wonder: spaces are by default ignored within definitions when +% the new packages are used due to a command \texttt{\textbackslash +% IgnoreWhiteSpace}, do get a normal space one has to use +% \texttt{\textasciitilde} and to obtain an unbreakable space +% \texttt{\textbackslash nobreakspace}.} gets ignored. +% +% We start by declaring the template \texttt{toosimple} of type +% \texttt{caption} having four mandatory arguments (as described in +% the discussion of the template type). +%\begin{verbatim} +%\DeclareTemplate{caption}{toosimple}{4} +%\end{verbatim} +% The next argument of |\DeclareTemplate| lists all keys for the +% template. In this case we have keys for the vertical spaces above +% and below. We make them type |L| to save on registers but with a bit +% of care we could also have used scratch registers like |\@tempskipa| +% etc. Their default values are both zero. +%\begin{verbatim} +% { +% above-skip =L [0pt] \caption@above@skip , +% below-skip =L [0pt] \caption@below@skip , +% } +%\end{verbatim} +% The final argument of |\DeclareTemplate| contains the actual +% processing code. We start with looking at the second mandatory +% argument (caption number) to find out if it is |\NoValue| and +% depending on the result define a helper command |\caption@start|. +%\begin{verbatim} +% { +% \IfNoValueTF{#2} +% { \def\caption@start{#1:~} } +% { \def\caption@start{#1~#2:~} } +%\end{verbatim} +% Having dealt with the prelims we now run |\DoParameterAssigments| at +% which point the keys of the template are made available, e.g., at +% this point all those right hand containers such as +% |\caption@above@skip| get assigned the value specified in an +% instantiation of the template. (That scheme allows to do preliminary +% processing up front, e.g., defaults for the keys could be assigned +% prior to that point in which case they are overwritten if the +% template instance specifies a different value. the use of specifying +% defaults via the |[..]| syntax as done above is slightly faster at +% run-time but needs more memory.) +%\begin{verbatim} +% \DoParameterAssigments +%\end{verbatim} +% The rest of the code should look familiar to anybody who ever looked +% at \texttt{article.cls}. The only point worth mentioning are the +% |\relax| commands after |\caption@above@skip| and +% |\caption@below@skip|. Since we have decided to use |L| as key type +% these commands are macros and not registers containing the +% dimensions as strings. This means that we have to be careful to +% ensure that \TeX{} knows where the dimension ends. In certain cases +% text following such a command might be mistaken as being part of the +% dimension (e.g., if followed by the word \texttt{plus}, etc.). In +% the code below this could only happen for the second |\vskip| but it +% is good practice to always add a terminating |\relax| to avoid such +% hidden traps. +%\begin{verbatim} +% \vskip \caption@above@skip \relax +% \sbox \@tempboxa {\caption@start #3} +% \ifdim \wd\@tempboxa >\hsize +% \caption@start #3\par +% \else +% \global \@minipagefalse +% \hb@xt@\hsize{\hfil\box\@tempboxa\hfil} +% \fi +% \vskip \caption@below@skip \relax +% } +%\end{verbatim} +% +% Why is the above template of not much use? Simply because it doesn't +% offer any flexibility to declare different designs. The only +% alteration offered to the designer is to modify the space above and +% below the caption, e.g., the following declaration would mimic the +% definition within the \texttt{article.cls} class of \LaTeXe: +%\begin{verbatim} +%\DeclareInstance{caption}{article}{toosimple} +% { +% above-skip = 0pt, +% below-skip = 10pt, +% } +%\end{verbatim} +% And that's all that can be manipulated. All items that people asking +% to change, e.g., not having a colon after the number, using +% different fonts and font sizes, etc.\ are still hard-wired and thus +% inaccessible. So we have to do better if we want to make use of the +% power the template mechanism offers. +% +% +% +% \subsection{Defining a better template} +% +% First step in defining better templates is to ask ourselves a couple +% of questions: +% \begin{itemize} +% \item What are the main characteristics of the layout the template +% is supposed to support? +% \item What are the elements that we want to allow (or can allow) the +% designer to modify? +% \end{itemize} +% +% Take the first question first: the layout supported by the template +% of the previous section had as its main characteristics that it +% would center the caption if it would fit in a single line in the +% current measure. We could consider this being an unchangable +% characteristic of the layout this template produces (and a designer +% would need to use a different template of type \texttt{caption} if a +% design compatible with this restriction is desired) or we could try +% to make our template smarter by adding bells and wistles that allow +% the designer to say stuff like: +%\begin{verbatim} +% one-line-format = \hfil #1 \hfil, +%\end{verbatim} +% or +%\begin{verbatim} +% one-line-action = center, +%\end{verbatim} +% depending on how we intend to offer changing the behavior of the +% template. Like when trying to define sensible template types we have +% no single road to heaven (and probably as many to hell) --- it has a +% lot to do with how we think about design. +% +% My advice, after having tried to work with these concepts for a +% while, is to keep templates simple in so far as that most of not all +% attribute for a template should be relevant for the design. In other +% words, if you have attributes that, depending on their setting, make +% half of the other attributes not applicable then it may be +% appropriate to think about providing several templates instead. To +% give an example from \LaTeXe: instead of having |\@startsection| +% deal with both vertical heads and run-in heads provide individual +% templates. (|\@startsection| is this famous command where design +% switches are build in by making dimensions negative to signal +% something and afterwards use the absolute value.) +% Another way to look at this is to say that a template should +% normally not contain large amounts of code which is only selected in +% a subset of attribute settings. +% +% As said before there are no golden rules, it is perfectly possible +% to make hugely complicated templates that solve every possible +% aspect of layout one could think of in one go --- it is just that +% with keeping it more simple one can get the same functionality with +% less headaches for the template writer as well as the template user +% later on. +% +% Returning to our example: allowing to handle the case of a single +% line caption specially could well be considered part of the +% template. In contrast: layouts that would put the caption number +% sideways, i.e., which would need totally different internal coding +% should probably be coded as a separate template of type +% \texttt{caption}. +% +% So for our next example template we settle for the fixed caption +% text plus number (if any) being at the beginning of the variable +% caption text (coming from the document) and being together formatted +% as some sort of a pargraph. In case of the whole caption being a +% single line we allow the designer to specify how to lay it out +% (e.g., centered, flush left, etc.). If there is a legend it will get +% formatted by a vertical space followed by the legend formatted as +% another paragraph. +% +% More precisely we allow for the following bells and wistles: +%\begin{verbatim} +%\DeclareTemplate{caption}{lesssimple}{4} +% { +%\end{verbatim} +% The designer can specify the space above and below the caption like +% we did in our first example. +%\begin{verbatim} +% above-skip =L [0pt] \caption@above@skip , +% below-skip =L [0pt] \caption@below@skip , +%\end{verbatim} +% Regarding the caption number we support the case where no number is +% present (the value being |\NoValue|) as well as the number being +% present. For both cases the designer has to specify what formatting +% should be attached. By default all is being typeset in the font the +% whole caption is presented but if there is a need for it the +% designer can use the following keys to attach special formatting +% devices to each particular item beside specifying special spacing +% information or replacing the default colon after the number with +% something else. +%\begin{verbatim} +% number-format =f2 [#1~#2:~] \caption@number@format, +% nonumber-format =f1 [#1:~] \caption@nonumber@format, +%\end{verbatim} +% If the caption is fitting onto a single line we make it possible +% for the designer to specify how this single line should be +% positioned (the default is to center the line). +%\begin{verbatim} +% single-line-format =f1 [\hfil#1\hfil] \caption@single@line@format, +%\end{verbatim} +% The font for the caption (including the fixed text and the number +% unless specified differently above) is going to be the one decided +% by the next key. +%\begin{verbatim} +% caption-font =f0 [\normalfont] \caption@font, +%\end{verbatim} +% The next attribute deserves some extra explanation: here we make use +% of an interface which is explained in more detail when we reveil the +% support for galley formatting.\footnote{Guess I have to apologize +% for the fact that i partly make use of that interface in this +% example while on other occasions (like the use of vertical spacing) +% within the example I do not---consistency around midnight is not my +% strength I fear (FMi).} In a nutshell the template type \texttt{hj} +% (hyphenation \& justification) allows one to define a) the +% justification concepts applied to the upcoming paragraphs, e.g., +% whether they should be set flush left, adjusted, first line +% centered, etc.\ b) the linebreaking strategy used and c) the +% hyphenation rules which should apply. All this is done by selecting +% an appropriate (predefined) instance of this type as will hopefully +% become somewhat clearer in the example instances shown below. +%\begin{verbatim} +% caption-hj-setup =i {hj} [default] \caption@hj@instance, +%\end{verbatim} +% In case there is a legend to format we give the designer the +% possibility to specify by how much vertical space it should be +% separated from the preceding paragraph (i.e., the caption text). The +% attributes for font and hj setup are comparable to those for the +% caption text itself (except that they will only apply to the +% legend). The only addition is the key \texttt{legend-text} which is +% allowed to take a fixed text (plus any formating and spacing for it) +% which will be added to the front of the legend in case it is +% provided at all (by default it is empty). +%\begin{verbatim} +% legend-sep =L [0pt] \caption@legend@sep , +% legend-text =f0 [] \caption@legend@text, +% legend-font =f0 [\normalfont] \caption@legend@font, +% legend-hj-setup =i {hj} [default] \caption@legend@hj@instance, +% } +%\end{verbatim} +% The actual code for the template should hold few if any +% surprises. In fact it is more or less identical to the one of the +% first template example, except that now we have now taken out some +% of the hardwired decisions and placed them into attributes. +%\begin{verbatim} +% { +% \IfNoValueTF{#2} +% { \def\caption@start{\caption@number@format{#1}{#2}} } +% { \def\caption@start{\caption@nonumber@format{#1}} } +% \DoParameterAssigments +% \vskip \caption@above@skip \relax +%\end{verbatim} +% To properly measure the caption to determine if it fits a single +% line we have to set it in the right font, so here as well as below +% we have to apply |\caption@font|. +%\begin{verbatim} +% \sbox \@tempboxa {\caption@font \caption@start #3} +% \ifdim \wd\@tempboxa >\hsize +% \begingroup +% \caption@font \caption@hj@instance +% \caption@start #3\par +% \endgroup +% \else +% \global \@minipagefalse +% \hb@xt@\hsize{\caption@single@line@format{\box\@tempboxa}} +% \fi +%\end{verbatim} +% To decide whether or not we have to set any legend we have to test +% |#4| for being |\NoValue|. This part of the code was not present in +% the previous example but otherwise should be straight forward. +%\begin{verbatim} +% \IfNoValueF{#4} +% { +% \vskip \caption@legend@sep \relax +% \begingroup +% \caption@legend@font \caption@legend@hj@instance +% \caption@legend@text +% #4\par +% \endgroup +% } +% \vskip \caption@below@skip \relax +% } +%\end{verbatim} +% +% I wouldn't claim the the above template is good or contains +% everything that would be desired and I'm sure that in the end we +% will have several such template for typesetting the caption part and +% perhaps decide on a different template type in the first place. So +% this is only to give a glimpse of how the template interface could +% be applied and I hope that reading it can see a) how they can apply +% it to other areas as well as see what is wrong with the example +% itself. +% +% To just note one point that i thought of being wrong after writing +% the above paragraphs: the key \texttt{single-line-format} was +% declared to be a function with one argument with the idea that +% besides specifying the single line should be centered (|\hfil|) on +% both sides, or flush left, or flush right (|\hfil| on one side) one +% could also specify something like +%\begin{verbatim} +% single-line-format = \hspace{10pt}#1\hfil, +%\end{verbatim} +% that is a fixed indentation on the left in case where the caption is +% a single line. However, of course one can't. Or at least it is not +% safe to do so since our test in the code tests the width of the line +% without taking into account such a finite fixed space and guess what +% might happen? So in summary, flexibility needs some thought and +% often some afterthoughts as well --- happy thinking :-) +% +% +% +% \subsection{Defining a few instances} +% +% So let us conclude this example with a few sample instances. We +% start with one that repeats what current \LaTeXe{} provides in the +% article class. It shows all keys with values. However in fact only +% the first key is actually needed since all others are the same as +% the default values in the template (and of course a legend is not +% specifiable in standard \LaTeX{} coding so those settings simply do +% not apply anyway). +%\begin{verbatim} +%\DeclareInstance{caption}{article}{lesssimple} +% { +% above-skip = 10pt, +% below-skip = 0pt, +% number-format = #1~#2:~, +% nonumber-format = #1:~, +% single-line-format = \hfil#1\hfil, +% caption-font = \normalfont, +% caption-hj-setup = default, +% legend-sep = 0pt, +% legend-text = , +% legend-font = \normalfont, +% legend-hj-setup = default, +% } +%\end{verbatim} +% +% The next examples are taken from books on the shelf essentially a +% random selection I fear. This one is from \emph{Introduction to +% Database Design} by C.~J.~Date and it uses Helvetica for the caption +% text with the caption flush left, with the figure and the fixed +% string (e.g., `Fig.' in bold face) separated by a quad of space. No +% legend either so this is not set up. The \texttt{hj} instance +% \texttt{noindentflushleft} is supposed to produce a ragged right paragraph +% without any indentation. It would have to be set up elsewhere +% (instance to the template of type \texttt{hj}). +%\begin{verbatim} +%\DeclareInstance{caption}{DATE}{lesssimple} +% { +% above-skip = 10pt, +% below-skip = 0pt, +% number-format = \textbf{#1~#2}\quad, +% nonumber-format = \textbf{#1}\quad, +% single-line-format = #1\hfil, +% caption-font = \fontfamily{phv} \normalfont, +% caption-hj-setup = noindentflushleft, +% } +%\end{verbatim} +% +% The final example is from the book ``Methods of Book Design'' by +% H.~Williamson which sets the caption centered if it fits a single +% line but adjusted as a paragraph without any indentation if longer +% than a single line. It uses old style numerals followed by a period +% for the number (though the example isn't quite right as i guess the +% text font used already has oldstyle numerals as default, so +% |\oldstylenums| is in fact not necessary). +%\begin{verbatim} +%\DeclareInstance{caption}{WILLIAMSON}{lesssimple} +% { +% above-skip = 10pt, +% below-skip = 0pt, +% number-format = #1~\oldstylenums{#2}.~, +% nonumber-format = #1~, +% single-line-format = \hfil#1\hfil, +% caption-font = \normalfont, +% caption-hj-setup = noindentadjusted, +% } +%\end{verbatim} +% +% +% +% \section{Notes} +% +% \subsection{Note on multi-valued parameters} +% +% +% The following code\footnote{docu taken from trial implementation in +% xlists.dtx, FMi} implements for registers (ie L,l,C,c keys) and +% for names (ie n key) a multi-selection mechanism of the following +% form: +% \begin{verbatim} +% key = \MultiSelection \@listdepth { +% \DelayEvaluation {2.5em}, +% 20pt + 34pt } +% { \DelayEvaluation {1em} }, +% \end{verbatim} +% where the first argument to |\MultiSelection| is a counter, the +% second argument is a comma separated list of values denoting the +% values for the cases 1, 2,\ldots, and the third argument contains +% the value for all other cases. +% +% The values are evaluated at declaration time in case of registers +% and therefore can contain calc expressions as well as +% |\DelayEvaluation|. +% +% Due to the implementation the case list is not allowed to have a +% trailing comma! And of course no checks are made whatsoever :-( +% +% A probably much nicer syntax would be something like this: +% \begin{verbatim} +% key = \MultiSelection { +% selector = \@listdepth, +% 1 = \DelayEvaluation {2.5em}, +% 2 = 20pt + 34pt, +% else = \DelayEvaluation {1em} +% }, +% \end{verbatim} +% but i found that too difficult to implement right now. +% +% I think it should also be considered if this kind of thing should be +% a generally available feature on all key types especially on the +% f\meta{number} ones. +% +% Anyway it is what i need for lists right now and as such it is +% sufficient. +% +% +% \subsection{Notes on template restriction} +% +% Possible semantics: +% +% a: just:-) changes the defaults ie the new template has as +% defaults those of its source as modified by the supplied +% keyvals; +% +% b: similar to a: but also removes some keywords ie the new template +% will not accept the keywods whose values are set by the suppied +% keyvals; +% +% c: plan C. +% +% +% Towards an implementation of b: but without a restriction on what +% keys appear where. +% +% +% +% +% \subsection{Open issues} +% +% In this section unresolved issues or ideas to think about and +% perhaps implement are collected. There is no particular order to +% them. +% +% \begin{itemize} +% \item The order of arguments in |\UseCollection| is illogical in my +% eyes! A collection typically modifies the behavior of several +% types and thus should perhaps be first (as it is in the +% |\DeclareCollectionInstance| case). Or not, or what? +% +% \item How should |\IfExistsInstanceTF| behave for Collection +% instances? Do we need a special check for those or a default +% action? Or do we need an additional test for the existence of +% collection instances? +% +% \item It was suggested that the template type declaration should get +% another argument in which (in?)formally the semantics for the +% template types are described, e.g., data type of arguments, +% resulting output, \ldots{} (somewhat like the description arguments +% for functions and variables in Emacs-Lisp). The advantage being +% that this helps employing the templates better as well as perhaps +% guiding context sensitive editors to support the work with such +% templates (e.g., providing help texts). +% +% \item The same might be of interest for the keys of individual +% templates though here syntax support is already available to some +% extend by the declaration of key types. +% +% \item There might be a need to distinguish between \TeX's dimen and +% skip registers. Right now this is not done and both |l| and |L| +% accepts what \LaTeX{} calls ``rubber length'' specifications. +% +% \item The type |b| can probably vanish. It is equivalent to +% specifying the mutators of a |\newif| command in the brace groups, +% e.g. +%\begin{verbatim} +% numbered-boolean =b [true] @heading@nums, +% numbered-boolean =s [true] {\@heading@numstrue} +% {\@heading@numsfalse}, +%\end{verbatim} +% +% \item See issue raised about syntax (and semantics) for +% |\Multiselection|. +% +% \end{itemize} +% +% \StopEventually{} +% +% \section{Implementation} +% \begin{macrocode} +%<*package> +% \end{macrocode} +% +% \begin{macrocode} +\RequirePackage{ldcsetup} +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% Declare a private token register for building parameter lists. +% Having the number saves a few expandafters +% (probably not needed in the end). +% \begin{macrocode} +\newtoks\TP@toks +\newtoks\TP@toksb +\newtoks\TP@toksc +% \end{macrocode} +% +% +% \begin{macro}{\functiondefine} +% |\def| setup with a latex style `number of arguments' argument. +% definition setup left in toksb for possible future use. +% \begin{macrocode} +\def\functiondefine#1#2#3{% + \def\@tempa##1#1##2##{% + \TP@toksb\expandafter{\expandafter\def\expandafter#2\@gobble##1#1} + \the\TP@toksb}% + \@tempa0##1##2##3##4##5##6##7##8##9{#3}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@DCI} +% Declare a command name to be an instance of a template +% ie with a particular setting of the parameters.\\ +% |#1| internal command name for instance to be (globally) declared\\ +% |#2| template type/template name\\ +% |#3| key value assignments for parameters of |#2| +% \begin{macrocode} +\def\TP@DCI#1#2#3{ + \begingroup + \TP@get@restrictions {#2} % puts stuff in \TP@toks + \toks@\expandafter\expandafter\expandafter + {\csname TPD>/#2\endcsname\relax\relax} + \setkeys{\the\TP@toksc} % temp OK? + {#3} % adds stuff to \TP@toks + \expandafter\TP@add@default \the\toks@ % prepends stuff to \TP@toks + \xdef#1{ + \expandafter\ifx\csname TP>/#2\endcsname\TP@dpa + \the\TP@toks + \else + \noexpand\TP@assignments{\the\TP@toks} + \expandafter\noexpand\csname TP>/#2\endcsname + \fi} + \endgroup} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@dpa} +% \begin{macrocode} +\long\def\TP@dpa{\DoParameterAssignments} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@add@default} +% \begin{macrocode} +\def\TP@add@default#1#2{ + \ifx#1\relax + \else + \@temptokena{#2} + \edef\@tempa{{\the\@temptokena\the\TP@toks}} + \TP@toks\@tempa + \expandafter\TP@add@default + \fi} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\UseTemplate} +% |{type}{templatename}{keyval}| +% Directly use a template with a particular parameter setting. +% This is also picked up if used in a nested fashion inside a parameter +% list.\\ +% |#1| type of a template.\\ +% |#2| name of a template.\\ +% |#3| key value assignments for parameters of |#1|. +% \begin{macrocode} +\def\UseTemplate#1#2#3{ + \TP@get@restrictions {#1/#2} % from here ... + \toks@\expandafter\expandafter\expandafter + {\csname TPD>/#1/#2\endcsname\relax\relax} + \setkeys{\the\TP@toksc}{#3} + \expandafter \TP@add@default \the\toks@ % to here is : + % Shared with \def\DeclareCommandInstance + \TP@push + \csname TP>/#1/#2\endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DoParameterAssignments} +% Acces the list stored in |\TP@toks|. +% \begin{macrocode} +\def\DoParameterAssignments{ + \expandafter\TP@pop\the\TP@stack\@@} +% \end{macrocode} +% +% \end{macro} +% +% \begin{macro}{\TP@pop} +% \begin{macrocode} +\def\TP@pop#1#2\@@{ + \global\TP@stack{#2} + #1} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@stack} +% \begin{macrocode} +\newtoks\TP@stack +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@stack} +% \begin{macrocode} +\global\TP@stack{\relax}% avoid brace loss +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@assignments} +% Access the list stored in |\TP@toks|. +% \begin{macrocode} +\def\TP@assignments{ + \afterassignment\TP@push\TP@toks} +% \end{macrocode} +% +% \end{macro} +% +% \begin{macro}{\TP@push} +% \begin{macrocode} +\def\TP@push{ + \global\TP@stack\expandafter + {\expandafter{\the\expandafter\TP@toks\expandafter} + \the\TP@stack}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareTemplateType} +% |{type}{nofarg}| +% \begin{macrocode} +\def\DeclareTemplateType#1#2{ + \expandafter\def\csname TP@<#1>\endcsname{{}#2}} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\TP@prefix} +% |{type}| returns prefix for csnames for type, based on current collection. +% \begin{macrocode} +\def\TP@prefix#1{ + <\expandafter\expandafter\expandafter + \@firstoftwo\csname TP@<#1>\endcsname>#1/} +% \end{macrocode} +% +% \end{macro} +% +% \begin{macro}{\TP@args} +% |{type}| returns arg count for type, +% \begin{macrocode} +\def\TP@args#1{ + \expandafter\expandafter\expandafter + \@secondoftwo\csname TP@<#1>\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\DeclareTemplate} +% |{type}{templatename}{nofarg}{keywordspec}{code}| +% \begin{macrocode} +\long\def\DeclareTemplate#1#2#3#4#5{ + \@ifundefined{TP@<#1>} + {\undefinedtype\DeclareTemplateType{#1}#3} + {\ifnum#3=\TP@args{#1}\relax\else + \BadArgCount\fi} +% \end{macrocode} +% Parse the key declaration, and execute the list with a suitable +% definition of |\KV@elt|. +% \begin{macrocode} + \let\KV@elt\TP@elt + \def\KV@default@elt##1{ + \PackageError{template}{Missing = after ##1}\@ehd} + \def\TP@name{#1/#2} + \toks@{} + \KV@parse{#4} +% \end{macrocode} +% +% Define the defaults +% \begin{macrocode} + \expandafter\edef\csname TPD>/\TP@name\endcsname{\the\toks@} +% \end{macrocode} +% +% Define the template +% \begin{macrocode} + \expandafter\newcommand\csname TP>/\TP@name\endcsname[#3]{#5}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@elt} +% The list of undefined keys and values is put in the list of the form\\ +% |\KV@elt|\marg{key}\marg{val}%^^A +% |\KV@elt|\marg{key}\marg{val}\ldots\\ +% So just need to give this macro a suitable definition. We just need +% to look at the first token of the value, to see what sort of key +% it is, so call a helper function to split that off. +% \begin{macrocode} +\def\TP@elt#1#2{% + \let\TP@global\@empty + \TP@do{#1}#2\TP@do} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@f@shift} +% Helper for |\TP@do|. +% \begin{macrocode} +\def\TP@f@shift#1#2{% + \TP@testopt{#1}{\TPkeycommand{#1}{#2}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@i@shift} +% Helper for |\TP@do|. +% \begin{macrocode} +\def\TP@i@shift#1#2{% + \TP@testopt{#1}{\TP@instance{#1}{#2}}} +% \end{macrocode} +% +% declaration |hd =i{head} \fooo| \\ +% use |hd = mine|\\ +% makes |\fooo| shorthand for |\UseInstance{head}{mine}| +% +% also allowed: |hd = \UseTemplate{head}{...}{...}|\\ +% in case you want to use an unnamed instance of type |head| +% in this place. +% \end{macro} +% +% \begin{macro}{\TP@instance} +% \begin{macrocode} +\def\TP@instance#1#2#3{ + \TP@define@key{#1}{ + \TPinstance#3{#2}{##1}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TPinstance} +% \begin{macrocode} +\def\TPinstance#1#2#3{ + \expandafter\ifx\@car#3.\@nil\UseTemplate + \typeout{\string\UseTemplate\space seen} +% \end{macrocode} +% +% code below from |\TPkeycommand| (should be combined and cleaned up) +% at this point one should also check if first arg of |\UseTemplate| +% corresponds to |#2| and if not complain (not done) +% +% \begin{macrocode} + {\TP@fudge#3} + \expandafter\addto@hook\expandafter\TP@toks\expandafter{ + \expandafter\KV@toks\expandafter{\TP@gtemp} + \edef#1{\the\KV@toks}} + \else + \@letinstance#1{#2}{#3} + \expandafter\expandafter\expandafter\addto@hook + \expandafter\expandafter\expandafter\TP@toks + \expandafter\expandafter\expandafter{ + \@letinstance#1{#2}{#3}} + \fi} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\TP@do} +% Case switch on the possible key types. +% \begin{macrocode} +\def\TP@do#1#2#3\TP@do{ + \ifx#2f + \TP@f@shift{#1}#3\@@ + \else\ifx#2n + \TP@testopt{#1}{\TPnamecommand{#1}}#3\@@ + \else\ifx#2l + \TP@testopt{#1}{\TP@register\setlength{#1}}#3\@@ + \else\ifx#2L + \TP@testopt{#1}{\TP@fakeregister\setlength\fake@length + {#1}}#3\@@ + \else\ifx#2c + \TP@testopt{#1}{\TP@register\SetInternalCounter{#1}}#3\@@ + \else\ifx#2C + \TP@testopt{#1}{\TP@fakeregister\SetInternalCounter\@tempcnta + {#1}}#3\@@ + \else\ifx#2b + \TP@testopt{#1}{\TP@setboolean{#1}}#3\@@ + \else\ifx#2s + \TP@testopt{#1}{\TP@booltest{#1}}#3\@@ + \else\ifx#2g + \TP@testopt{#1}{\TP@setgeneral{#1}}#3\@@ + \else\ifx#2x + \TP@testopt{#1}{\TP@setx{#1}}#3\@@ + \else\ifx#2i + \TP@i@shift{#1}#3\@@ + \else\ifx#2+ + \def\TP@global{\addto@hook\TP@toks{\global}} + \TP@do{#1}#3\TP@do + \else + \PackageError{template}{Unknown~key~type~ (#2)~for~#1}\@eha + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \fi + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@testopt} +% \begin{macrocode} +\def\TP@testopt#1#2{ + \@ifnextchar[%] + {\TP@test@pt{#1}{#2}} + {\TP@zap@@{#2}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@zap@@} +% \begin{macrocode} +\def\TP@zap@@#1#2\@@{ + #1{#2}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@test@pt} +% \begin{macrocode} +\def\TP@test@pt#1#2[#3]#4\@@{ + #2 + {#4} + \begingroup + \TP@toks{} + \let\TP@remove\@gobble + \csname KV@\TP@name @#1\endcsname{#3} + \expandafter + \endgroup + \expandafter + \toks@\expandafter{ + \csname KV@\TP@name @#1\expandafter\endcsname\expandafter + {\the\expandafter\TP@toks\expandafter}\the\toks@}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@setgeneral} +% \begin{macrocode} +\def\TP@setx#1#2{ + \TP@define@key{#1}{\addto@hook\TP@toks{#2}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@setgeneral} +% \begin{macrocode} +\def\TP@setgeneral#1#2{ + \TP@define@key{#1}{#2}} +% \end{macrocode} +% +% \end{macro} +% +% \begin{macro}{\TP@setboolean} +% \begin{macrocode} +\def\TP@setboolean#1#2{ + \expandafter\let\csname if#2\endcsname\iftrue + \TP@define@key{#1}{ + \TPsetboolean{#2}{##1}} +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TPsetboolean} +% Modify so the boolean does not need to have been +% declared with |\newif| +% \begin{macrocode} +\def\TPsetboolean#1#2{ + \expandafter\ifx\csname if#2\endcsname\relax + \PackageError{template}{Bad~boolean~setting~#1=#2}\@eha + \else + \expandafter\let\csname if#1\expandafter\endcsname + \csname if#2\endcsname + \expandafter\addto@hook\expandafter\TP@toks\expandafter{ + \expandafter\let + \csname if#1\expandafter\endcsname\csname if#2\endcsname} + \fi} +% \end{macrocode} +% +% \end{macro} +% +% \begin{macro}{\TP@booltest} +% \begin{macrocode} +\def\TP@booltest#1#2{ + \TP@define@key{#1}{ + \TPbooltest{##1}#2}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@true} +% \begin{macrocode} +\def\TP@true{true} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TPbooltest} +% \begin{macrocode} +\def\TPbooltest#1#2#3{ +% no error check on this yet. + \def\@tempa{#1} + \ifx\@tempa\TP@true + \addto@hook\TP@toks{#2} + \else + \addto@hook\TP@toks{#3} + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@register} +% This is normally called automatically by |\DeclareTemplate|. +% +% Command for setting a template attribute whose name +% corresponds directly to a tex count or length register\\ +% |#1| the fuction to set the value eg \setlength.\\ +% |#2| key name.\\ +% |#3| the register to set. +% +% This command \emph{fully evaluates} the argument at declare time, +% and assigns the value to the register. It also passes an assignment +% of the register to the final value into the parameter list for the +% template. +% +% If the value is a call to |\DelayEvaluation|, don't evaluate it now, +% just pass the whole assignment to the template. +% +% [Note that the code below contains some : being used in csnames in other files +% this is currently being allowed by default but in this one it is right now +% manually added --- need fixing either way] +% \begin{macrocode} +\catcode`\:=11\relax +\def\TP@register#1#2#3{ + \TP@define@key{#2}{ + \expandafter\ifx\@car##1\@nil\DelayEvaluation + \addto@hook\TP@toks{#1#3{##1}} + \else +% \end{macrocode} +% +% +% check for |\MultiSelection| creeping up and if so add something like +% +% \begin{verbatim} +% \setlength\register{\ifcase\selector \or value1 \or value2 +% ... \else valueotherwise \fi} +% \end{verbatim} +% to |\TP@toks|. +% +% \begin{macrocode} + \expandafter\ifx\@car##1..\@nil\MultiSelection + \begingroup + \TP@multi#1#3##1 + \endgroup +% \end{macrocode} +% +% +% there are probably better ways to do this :-) +% +% \begin{macrocode} + \expandafter\in@\expandafter\DelayEvaluation + \expandafter{\the\TP@multi@toks} + \ifin@ + \addto@hook:No\TP@toks + {\expandafter#1\expandafter#3\expandafter + {\the\TP@multi@toks}} + \else + \addto@hook:No\TP@toks + {\expandafter #3 + \expandafter= \the\TP@multi@toks\relax} + \fi +% \end{macrocode} +% +% +% otherwise do as before +% +% \begin{macrocode} + \else + #1#3{##1} + \addto@hook:No\TP@toks + {\expandafter #3 + \expandafter= \the#3\relax} + \fi\fi}} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\addto@hook:No} +% \begin{macrocode} +\def\addto@hook:No#1#2 { + \expandafter\addto@hook\expandafter#1\expandafter{#2}} +\catcode`\:=12\relax +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\DelayEvaluation} +% \begin{macrocode} +\let\DelayEvaluation\@firstofone +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TPkeycommand} +% Same for macro names. Again usually called automatically when +% declaring a new template.\\ +% |#1| the key.\\ +% |#2| Determines how many arguments the function should have.\\ +% |#3| The macro to be defined. +% +% If the `|##1|`, the value passed as the argument of the key |#1| +% to the macro |#3| is invoked starts with |\FunctionInstance|, then a +% special procedure is taken. Instead of defining a macro with the +% specified number of arguments, the paramater list of the nested +% function instance is parsed, and |#3| is defined to be a macro +% expanding to that instance. In this case the specified template +% is responsible for picking up the requested number of +% arguments. (This is \emph{not} checked.) +% \begin{macrocode} +\def\TP@define@key#1#2{% + \expandafter\def + \csname KV@\TP@name @#1\expandafter\endcsname + \expandafter##\expandafter1 + \expandafter{ + \expandafter\TP@remove + \csname KV@\TP@name @#1\expandafter\endcsname + \TP@global + #2}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@remove} +% \begin{macrocode} +\def\TP@remove#1{ + \def\@tempa##1#1##2##3#1##4\@@{ + \toks@{##1##3}} + \expandafter\@tempa\the\toks@#1\relax#1\@@} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TPkeycommand} +% \begin{macrocode} +\def\TPkeycommand#1#2#3{ + \TP@define@key{#1}{ +% \end{macrocode} +% +% |##1| can either be arbitrary inline code, in which case it will be +% defined with |\newcommand[val]| so it needs to use |#1| -- |#val|. +% +% define it locally here +% \begin{macrocode} + \functiondefine#2#3{##1} +% \end{macrocode} +% +% \begin{macrocode} + \expandafter\addto@hook\expandafter\TP@toks\expandafter{ + \the\TP@toksb{##1}} + } + } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\TPnamecommand} +% Here is the extended version that tries to deal with +% |\MultiSelection|. +% +% In case of `n' keys there is no evaluation at declaration time so it +% is not sensible to look for |\DelayEvaluation|. For this reason as +% well as for the fact that |\TP@multi| above assumes that it deals +% with registers that can be accessed via |\the| we have to use a +% different command to handle the |\MultiSelection| args but +% it is essentially doing the same. +% +% \begin{macrocode} +\catcode`\:=11\relax +\def\TPnamecommand#1#2{ + \TP@define@key{#1}{ + \expandafter\ifx\@car##1..\@nil\MultiSelection + \begingroup + \TP@multi@name##1 + \endgroup + \addto@hook:No\TP@toks + {\expandafter\def\expandafter#2\expandafter + {\the\TP@multi@toks}} + \else + \def#2{##1} % setting it? + \addto@hook\TP@toks{\def#2{##1}} + \fi + } + } +\catcode`\:=12\relax +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@multi@name} +% \begin{macrocode} +%\catcode`\:=12\relax +\def\TP@multi@name #1#2#3#4{ + \global\TP@multi@toks{\ifcase #2} + \@for\next:=\@empty #3\do{ + \TP@do@multi\next +} + \global\addto@hook\TP@multi@toks{\else #4\fi} + } +%\catcode`\:=11\relax +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% +% +% \begin{macro}{\DeclareInstance} +% |{type}{instname}{templatename}{keyval}| +% \begin{macrocode} +\def\DeclareInstance{\DeclareCollectionInstance{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareCollectionInstance} +% |{collection}{type}{instname}{templatename}{keyval}| +% \begin{macrocode} +\long\def\DeclareCollectionInstance#1#2#3#4{ + \expandafter\TP@DCI\csname<#1>#2/#3\endcsname{#2/#4}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\UseCollection} +% |{type}{collection}| +% \begin{macrocode} +\def\UseCollection#1#2{ + \expandafter\edef\csname TP@<#1>\endcsname{ + {#2} + \TP@args{#1}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@letinstance} +% |\internalcommand{type}{instname}| +% \begin{macrocode} +\def\@letinstance#1#2#3{ + \expandafter\let\expandafter#1\csname + \@ifundefined{\TP@prefix{#2}#3} + {<>#2/} + {\TP@prefix{#2}} + #3 + \endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\UseInstance} +% |{type}{instname}| +% \begin{macrocode} +\def\UseInstance#1#2{ + \@letinstance\@tempa{#1}{#2} + \ifx\@tempa\relax + \INSTANCEundefined + \else + \expandafter\@tempa + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@fudge} +% \begin{macrocode} +\long\def\TP@fudge#1#2#3{% + \TP@DCI\TP@gtemp{#2/#3}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ShowTemplate} +% Some extension to |\ShowTemplate| so that we also get to see the +% restrictions if any +% \begin{macrocode} +\def\ShowTemplate#1#2{ + \typeout{*******~ Template:~ #1/#2~ *******} + \typeout{*} + \typeout{*~ Defaults:} + \typeout{*} + \typeout{\string\TPD>/#1/#2= + \expandafter\meaning\csname TPD>/#1/#2\endcsname} + \typeout{*} + \typeout{*~ Restrictions:} + \typeout{*} + \typeout{\string\TPR>/#1/#2= + \expandafter\meaning\csname TPR>/#1/#2\endcsname} + \typeout{*} + \typeout{*~ Body:} + \typeout{*} + \expandafter\show\csname TP>/#1/#2\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\ShowCollectionInstance} +% \begin{macrocode} +\def\ShowCollectionInstance#1#2#3{ + \typeout{*******~ Instance:~ <#1>#2/#3~ *******} + \typeout{*} + \expandafter\show\csname <#1>#2/#3\endcsname} +\def\ShowInstance{\ShowCollectionInstance{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@fakeregister} +% |{setcomand}{privateregister}{key}{internalcode}| +% \begin{macrocode} +\catcode`\:=11\relax +\def\TP@fakeregister#1#2#3#4{ + \TP@define@key{#3}{ + \expandafter\ifx\@car##1..\@nil\DelayEvaluation +% \end{macrocode} +% In the v0.08 version of \texttt{template.dtx} a +% |\DelayEvaluation| for a faked register would simply be equiv to +% a |\def| (code is below commented out). The negative side effect +% of this is that something like |=L| used with |\DelayEvaluation| +% would not allow for calc syntax since it would end up as +% |\def|\allowbreak|\foo|\allowbreak|{a+b}|. The code below changes +% this to first assign to a scratch register (at runtime) and then +% do an |\edef|. Could be coded differently to save space (at cost +% of time) +% \begin{macrocode} +% \addto@hook\TP@toks{\def#4{##1}} + \addto@hook\TP@toks{#1#2{##1}\edef#4{\the#2}} + \else +% \end{macrocode} +% +% +% Otherwise same game for fake registers except that instead of +% passing the register to |\TP@multi| we pass a temp fake one and +% doing a def instead of using |\setlength| or |\setcounter| +% +% and i haven't done the |\DelayEvaluation| bit for that case! as +% i'm not sure what the best approach is for those +% things\footnote{we might disallow it for that case in general --- +% not a nice rule but an explainable one} +% +% \begin{macrocode} + \expandafter\ifx\@car##1..\@nil\MultiSelection + \begingroup + \TP@multi#1#2##1 + \endgroup + \addto@hook:No\TP@toks + {\expandafter\def\expandafter#4\expandafter + {\the\TP@multi@toks}} + \else + #1#2{##1} + \addto@hook:No\TP@toks + {\expandafter + \def + \expandafter + #4 + \expandafter + {\the#2}} + \fi\fi}} +\catcode`\:=12\relax +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\TP@multi@toks} +% \begin{macrocode} +\newtoks\TP@multi@toks +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@multi} +% \marg{operation} \marg{register} |\MultiSelection| +% \marg{selector} \marg{case-list} \marg{else-case} +% +% This command builds up the |\ifcase| code from the three arguments +% of |\MultiSelection| and stores it in |\TP@multi@toks|. This code is +% supposed to be run in a group so a) we don't have to initialise +% |\TP@multi@toks| and b) all changes to the used registers not +% affecting the outside. +% +% Warning: this code uses |\@for| which will not work if put into files where +% ``:'' was made a letter! +% +% \begin{macrocode} +%\catcode`\:=12\relax +\def\TP@multi #1#2#3#4#5#6{ + \global\TP@multi@toks{\ifcase #4} + \@for\next:=\@empty #5\do{ + \expandafter \expandafter\expandafter\ifx\expandafter + \@car\next..\@nil\DelayEvaluation + \TP@do@multi\next + \else + #1#2{\next} + \TP@do@multi{\the#2} + \fi + } + \global\addto@hook\TP@multi@toks{\else #6\fi} + } +%\catcode`\:=11\relax +% \end{macrocode} +% +% Since we intend to add |\or| to |\TP@multi@toks| within the |\@for| +% loop we have to hide it carefully or else we will get some unmatched +% conditionals. +% \end{macro} +% +% \begin{macro}{\TP@do@multi} +% \begin{macrocode} +\def\TP@do@multi#1{ + \global\expandafter\addto@hook\expandafter\TP@multi@toks + \expandafter{\expandafter\or #1 } +} +% \end{macrocode} +% \end{macro} +% +% Since i like to set things like |item-label-text| using this +% mechanism i need to handle the `n' key specially. +% +% Actually i could have probably extended |\TPkeycommand| thus making +% this generally available to all f\meta{number} keys but was too lazy +% (or too stupid) to get it right first time so settled for the simple +% solution. +% +% So |\TP@do| now calls |\TPnamecommand| for the `n' key. looks like +% this thus be fixed some time soon +% +% +% +% +% +% +% \begin{macro}{\fake@length} +% \begin{macrocode} +\newlength\fake@length +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\IfExistsInstanceTF} +% tests that there is a \emph{default} definition +% taken from xinitials.dtx: +% \begin{macrocode} +\def\IfExistsInstanceTF#1#2{ + \expandafter\ifx\csname <>#1/#2\endcsname\relax + \expandafter\@secondoftwo + \else + \expandafter\@firstoftwo + \fi} +% \end{macrocode} +% +% FMi: what happens if we are in collection FOO and there exists an +% instance I for type T within this collection but there doesn't exist +% an instance in the empty collection? +% +% What would happen if \ldots\ --- not clear to me what the sematics +% really should be. The code below is not better only different( and +% slower).\footnote{fix semantics} +% \begin{macrocode} +\def\IfExistsInstanceTF#1#2{ + \@letinstance\@tempa{#1}{#2} + \ifx\@tempa\relax + \expandafter\@secondoftwo + \else + \expandafter\@firstoftwo + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareRestrictedTemplate} +% Setting it up: +% +%| \DeclareRestrictedTemplate|\\ +% |{T-type} {new-T-name} {source-T-name} {keyvals}| +% +% This uses the same code as {T-type} {source-T-name} but adds +% settings from {keyvals} +% \begin{macrocode} +\def\DeclareRestrictedTemplate#1#2#3#4{ + % CCC do we need a group here?? + \letcc { TPD>/#1/#2 } { TPD>/#1/#3 } + \letcc { TP>/#1/#2 } { TP>/#1/#3 } + \TP@get@restrictions {#1/#3} % puts stuff in \TP@toks + \setkeys{\the\TP@toksc} % temp OK? + {#4} % adds stuff to \TP@toks + \TP@store@restrictions {#1/#2}{#1/#3}} % stores the contents of + % \TP@toks +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\letcc} +% \begin{macrocode} +\def\letcc#1#2{ + \expandafter \let + \csname #1 \expandafter \endcsname + \csname #2 \endcsname} +% \end{macrocode} +% \end{macro} +% +% Internals: +% +% \begin{macro}{\TP@get@restrictions} +% These could probably be inlined, even when they do something! +% \begin{macrocode} +\def\TP@get@restrictions#1{ % Returns to \TP@toks the restrictions + % stored in the TP-structure (at present + % in YAM) of the template #1 + \@ifundefined {TPR>/#1} + {\TP@toks {}} + {\TP@toks \expandafter\expandafter\expandafter + {\csname TPR>/#1\endcsname}} + \@ifundefined {TPO>/#1} + {\@namedef {TPO>/#1} {#1} + \TP@toksc {#1} } % temp OK? + {\TP@toksc \expandafter\expandafter\expandafter + {\csname TPO>/#1\endcsname} }} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\TP@store@restrictions} +% \begin{macrocode} +\def\TP@store@restrictions#1#2{ % Stores the contents of \TP@toks + % in the TP-structure (at present + % in YAM) of the template #1 + \expandafter\edef\csname TPR>/#1\endcsname{\the\TP@toks} + \@ifundefined{TPO>/#2} + {\@namedef{TPO>/#1}{#2}} + {\letcc{TPO>/#1}{TPO>/#2}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% \Finale +% + + + diff --git a/Master/texmf-dist/source/latex3/template/template.ins b/Master/texmf-dist/source/latex3/template/template.ins new file mode 100644 index 00000000000..b8fe0900dc8 --- /dev/null +++ b/Master/texmf-dist/source/latex3/template/template.ins @@ -0,0 +1,12 @@ +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble +\endpreamble + +\generate{% + \file{template.sty}{\from{template.dtx}{package}} + } + +\endbatchfile diff --git a/Master/texmf-dist/source/latex3/xinitials/xinitials.dtx b/Master/texmf-dist/source/latex3/xinitials/xinitials.dtx new file mode 100644 index 00000000000..1bc00c320ea --- /dev/null +++ b/Master/texmf-dist/source/latex3/xinitials/xinitials.dtx @@ -0,0 +1,553 @@ +% \iffalse +%% +%% $Header: /usr3/users/latex3/design/consolidation/CURRENT/RCS/xinitials.dtx,v 1.7 2000/01/28 13:39:56 latex3 Exp $ +%% +%% (C) Copyright 1999-2000 Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{xinitials.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{xinitials} +%<signature>\ProvidesFile{xinitials.sig} +%<driver>\ProvidesFile{xinitials.drv} +% \fi +% \ProvidesFile{xinitials.dtx} + [2000/01/28 v0.1h templates for initials] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} + \usepackage{textcomp} +% \usepackage{ldcdoc} + +% next three definitions are big hacks to run the file +% without the above packages +% +\newcommand\NoValue{\texttt{\textbackslash NoValue}} + +\makeatletter +\newenvironment{TemplateInterfaceDescription}[1] + {\subsection{The Template Type `#1'}% + \begingroup + \@beginparpenalty\@M + \description + \def\TemplateArgument##1##2{\item[Arg: ##1]##2\par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics:}}% + } + {\par\bigskip} + +\newenvironment{TemplateDescription}[2] + {\subsection{The Template `#2' (type #1)}% + \subsubsection*{Attributes:}% + \begingroup + \@beginparpenalty\@M + \description + \def\TemplateKey##1##2##3##4{\item[##1 (##2)]##3% + \ifx\TemplateKey##4\TemplateKey\else +% \hskip0ptplus3em\penalty-500\hskip 0pt plus 1filll Default:~##4% + \hfill\penalty500\relax\qquad \hbox{}\hfill Default:~##4% + \nobreak\hskip-\parfillskip\hskip0pt\relax + \fi + \par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics \& Comments:}}% + } + {\par\bigskip} + +\makeatother + +\newcommand\LaTeXplus{\LaTeXe$*$} +\newcommand\key[1]{\textbf{#1}} + + \EnableCrossrefs + \CodelineIndex + \begin{document} + \DocInput{xinitials.dtx} + \PrintIndex + \end{document} +%</driver> +% \fi +% +% \CheckSum{125} +% +% \GetFileInfo{xinitials.dtx} +% +% \title{The \textsf{xinitials} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{FMi} +% \date{\filedate} +% \maketitle +% +% \tableofcontents +% +% \section{Introduction} +% +% This module implements an interface for producing initial +% characters. It was originally written as an exercise for working +% with the template interface of \LaTeXplus{} and survived many +% internal changes of the new methods. +% +% +% \section{Interfaces} +% +% The template implemented by this module uses absolute dimensions to +% produce the initials, something which I found being a natural way to +% achieve the desired results. There are other ways to specify how +% such initials should look; for example there exists a \LaTeXe{} +% package called \texttt{lettrine} by Daniel Flippo which makes the +% specifications relative to the current font used for the initials. +% It would be interesting to see his approach being reimplemented as +% an alternative template to the one I called \texttt{std}. +% +% +% \begin{TemplateInterfaceDescription}{initial} +% +% \TemplateArgument{1} +% {Quote to the left of the initial (if any) or \NoValue} +% +% \TemplateArgument{2} +% {Initial character} +% +% \TemplateArgument{3} +% {Text following the initial that is handled specially, e.g., +% set in small capitals (if any) or \NoValue } +% +% \TemplateSemantics +% Typesets argument 2 as an initial character with argument 1 being +% any special material typeset to the left of the initial (e.g., a +% quote) and argument 3 being all material that is typeset in a +% special fashion to the right of the initial. +% +% In typical document commands arguments 1 and 3 are most likely +% implemented as optional, if implemented at all. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{initial}{std} +% +% \TemplateKey{initial-font}{f0} +% {Font specification to use for the initial glyph itself.} +% {None} +% +% \TemplateKey{initial-format}{f1} +% {Action to be taken on the initial. +% This action takes one argument: the initial glyph formated +% using \key{initial-font} but not including +% the left and right separation spaces from \key{quote-sep} and +% \key{text-sep}. The result if this action is further +% manipulated by other keys.} +% {Process argument unchanged} +% +% \TemplateKey{text-format}{f1} +% {Action to be take on the special text following +% the initial. This action takes one argument: argument 3 of the +% template if not \NoValue.} +% {Produce Caps\&SmallCaps} +% +% \TemplateKey{quote-format}{f1} +% {Action to be taken on a quotation glyph to the left of the +% initial (i.e., argument 1 of the template, if not \NoValue). +% This action takes one argument: the quote glyph.} +% {Process argument unchanged} +% +% \TemplateKey{parshape-list}{f0} +% {List of dimensions (separated by comma) specifying two things: +% For how many lines the paragraph needs indentation due do the +% initial, i.e., how far does it drop into the paragraph +% (number of dimensions) and how much each line should +% be indented in addition to the actual width of the initial +% including its offsets from \key{text-sep} and \key{h-adjust} +% (value of the individual dimension which +% could be negative) --- because of the commas in the list the +% whole list has to be surrounded by braces.} +% {Initial does not drop: \texttt{0pt}} +% +% \TemplateKey{v-adjust}{l} +% {Dimension used to adjust the initial (see above) +% vertically (positive values raise it). Default value places +% the initial at the baseline of the +% last indented paragraph line.} +% {\texttt{0pt}} +% +% \TemplateKey{h-adjust}{l} +% {Dimension used to adjust the initial horizontally (positive +% values move it to the right). Default value places the initial +% flush left with the text margin.} +% {\texttt{0pt}} +% +% \TemplateKey{quote-sep}{l} +% {Dimension specifying the space between the initial +% and any ``quote material'' on its left (see also +% \key{initial-format}).} +% {\texttt{0pt}} +% +% \TemplateKey{text-sep}{l} +% {Dimension specifying the space between the initial +% and the paragraph lines on the right (see also +% \key{parshape-list}). This key is available for convenience, it +% is equivalent of extending all values in \key{parshape-list} +% by this amount.} +% {\texttt{0pt}} +% +% \TemplateKey{nominal-height}{l} +% {Dimension specifying the height of the initial as seen by +% \TeX. If not specified, the height is calculated as the actual +% dimension of the initial (after applying \key{initial-format}) +% plus the value of \key{top-sep}.} +% {Unspecified} +% +% \TemplateKey{top-sep}{l} +% {Dimension specifying an extra separation from preceding +% material by pretending that the initial larger (or smaller) +% than it actually is (see also \key{nominal-height} for special +% effects).} +% {\texttt{0pt}} +% +% \TemplateSemantics +% The template will raise an error if used in horizontal mode. It +% will also complain if it finds that it is used with a special +% |\parshape| in force (other than the one produced from list environments. +% +% \end{TemplateDescription} +% +% +% +% +% \subsection{The Document Interface} +% +% The following two commands should be viewed as examples on how one +% could set up a document interface for initials. +% +% \DescribeMacro\Initial +% The |\Initial| command takes one mandatory argument which is the +% initial character. It may be followed by an optional argument, +% which, if present, denotes the portion of text following the initial +% character that should be handled somewhat special (for example being +% set in caps \& smallcaps). It can also take an optional argument +% before the mandatory one, which, if present, contains material that +% should be placed to the left of the initial (in the margin). It can +% be used, for example, for placing quotes at this point. +% +% The mandatory argument can only contain a straight \textsc{ascii} +% letter and not something like an accented character. The reason is +% that the |\Initial| command tries to find a template instance using +% the the argument as the potential name.\footnote{This is for +% convenience only, if one often needs special initial one would better +% define a different interface.} If it find such an instance it will +% use it, otherwise it will use the instance with name +% \texttt{default}. This scheme makes it possible to declare one +% instance (\texttt{default}) with values being suitable for most +% characters and define overwriting instances for those character +% which need special treatment. +% +% +% \DescribeMacro\ExtendedInitial +% The |\ExtendedInitial| is an extension of the interface provided by +% the |\Initial| command. It accepts a star in which case a following +% optional argument is interpreted as the key/value specification for +% the template \texttt{std} of type \texttt{initial} which is then +% constructed on the fly. The remaining three arguments (optional, +% mandatory, optional) are as in the case of |\Initial|. If no star is +% present the first optional argument is interpreted as the name of +% the template instance. If it is defined then it is used; if not the +% instance with name \texttt{default} is used. This way the mandatory +% argument is allowed to contain any \TeX{} code including accents and +% the like. For example, +%\begin{verbatim} +% \ExtendedInitial [Uumlaut][``]{\"U}[ber den sieben Bergen] bei ... +%\end{verbatim} +% would use the instance with name \texttt{Uumlaut} (which would need +% to be defined) to typeset the `\"U' as initial with a left double +% quote on the left and the text `ber den sieben Bergen' handled +% specially. +% +% \StopEventually{} +% +% \section{Implementation} +% +% \subsection{The template implementation} +% +% \begin{macrocode} +%<*package> +% \end{macrocode} +% +% For this module we need the galley support and of course the +% template module. +% \begin{macrocode} +\RequirePackage{template,galley2} +% \end{macrocode} +% +% Getting our private coding environment ready\ldots +% \begin{macrocode} +\IgnoreWhiteSpace +\catcode`\:=11\relax +% \end{macrocode} +% +% At some point below we need a register to do some calculations. We +% could probably get away with a scratch one but here I allocated a +% private one to avoid having to think about the implications :-) +% \begin{macrocode} +\newlength\initial@raise +% \end{macrocode} +% +% We also need a box register to be able to measure the size of the +% initial and its frills, again this could probably be done with a +% general purpose register but\ldots +% \begin{macrocode} +\newbox\initial@box +% \end{macrocode} +% +% +% +% \bigskip +% +% The \texttt{initial} template type has three arguments: +% \begin{macrocode} +\DeclareTemplateType{initial}{3} +% \end{macrocode} +% +% +% +% \bigskip +% +% \begin{macrocode} +\DeclareTemplate{initial}{std}{3}{ +% \end{macrocode} +% The font to be used for the initial does not have any default +% value: it must be specified. +% \begin{macrocode} + initial-font =f0 \initial@font, +% \end{macrocode} +% All other keys have default values but we do not specify the here. +% \begin{macrocode} + h-adjust =L \initial@hadjust, + initial-format =f1 \initial@charformat, + nominal-height =L \initial@height, + parshape-list =f0 \initial@parshape, + quote-format =f1 \initial@quoteformat, + quote-sep =L \initial@leftsep, + text-format =f1 \initial@textformat, + text-sep =L \initial@rightsep, + top-sep =L \initial@topsep, + v-adjust =L \initial@vadjust, +} +{ +% \end{macrocode} +% Specifying the defaults here saves space, otherwise each instance would +% contain them. +% \begin{macrocode} + \let\initial@vadjust\z@ + \let\initial@hadjust\z@ + \let\initial@leftsep\z@ + \let\initial@rightsep\z@ + \let\initial@height\maxdimen + \let\initial@topsep\z@ + \let\initial@parshape\z@ + \let\initial@quoteformat\@firstofone + \let\initial@charformat\@firstofone + \let\initial@textformat\textsc + \DoParameterAssignments +% \end{macrocode} +% +% We first check if we are in vertical mode and if not raise an error. +% \begin{macrocode} + \ifvmode \else + \PackageError{xinitials}{Initial~ inside~ paragraph} + {Initials~ can~ only~ be~ used~ at~ the~ beginning~ + of~ a~ paragraph} + \par + \fi +% \end{macrocode} +% We then typeset the initial character in a box to be able to +% measure it. The purpose of this measurement is to determine the +% width of the cutout, thus we have to include the specified +% horizontal adjustments on the left and the right. +% \begin{macrocode} + \sbox\initial@box{ + \kern\initial@hadjust + \initial@charformat{ + \initial@font #2 + } + \kern\initial@rightsep + } +% \end{macrocode} +% We then prepare the cutout using |\setGALleftparshape:nnn| (see +% the module \texttt{galley2} for an explanation of this command). +% \begin{macrocode} + \setGALleftparshape:nnn \z@ {\wd\initial@box} + \initial@parshape +% \end{macrocode} +% It would be a problem if the paragraph containing the initial +% would be split across the page, so we forbid paragraph splits +% for the next paragraph. (We use the value |-3| which indicates +% that it is allowed to break before the paragraph). +% \begin{macrocode} + \setGALbreak:n {-3} + \noindent +% \end{macrocode} +% Next lines of code calculate the vertical dimension by which we +% have to raise (normally lower in fact) the . The value of +% |\parshape@linecnt| which is used in the formula was calculated +% by |\setGALleftparshape:nnn|. +% \begin{macrocode} + \setlength\initial@raise{-\baselineskip*(\parshape@linecnt-2) + -\initial@vadjust} +% \end{macrocode} +% +% We then calculate the vertical space that the initial should +% occupy (with respect to the first baseline of the paragraph). +% If |\initial@height| is |\maxdimen|, i.e., was not set then the +% effective height of the initial should be its real height +% (|\height| reduced by the amount we drop (|\initial@raise|) plus +% the extra space requested (|\initial@topsep|). If however the +% value of |\initial@height| differs from |\maxdimen| we use that +% value directly.\footnote{Writing the documentation for this I +% notice that it might be better to change the logic here +% completely: assume that the initial sticks out of the +% paragraph. Now we have to account for this sticking out to avoid +% that the initial bumps into the previous paragraph. However, if +% we do it as it is currently implemented then this vertical extend +% is actually a property of the initial character box. This means +% that if we have a page break before the paragraph containing the +% initial we do get a paragraph whose first line is far lower on +% the page than in the care there would be a normal paragraph (in +% other words the initial would not stick into the top margin but +% be confined to the body text area). This may be what is intended, +% on the other hand it may be not. So perhaps one need to allow to +% contribute this vertical space to the inter-paragraph material.} +% \begin{macrocode} + \ifdim\initial@height=\maxdimen + \def\initial@height{\height+\initial@raise+\initial@topsep} + \fi +% \end{macrocode} +% +% Now we about ready to typeset the initial. We put the whole thing +% into an |\llap|. If we do have some material to the left of the +% initial we set it in a way that its height and its width has no +% influence. To prevent the width of the material effecting the +% placement of the actual initial character we set the material in +% an |\llap|. The right corner of this |\llap| will be at the left +% paragraph boundary. But the initial might have been moved +% horizontally so that we have to account for this space +% (|-\initial@hadjust|). In addition there should be a separation +% between the material and the initial of width +% |\initial@leftsep|. Both spaces are added as |\kern|s to the +% |\llap| box to provide the necessary separation. +% \begin{macrocode} + \llap{ + \llap{\IfValueT{#1}{\smash{\initial@quoteformat{#1}}} + \kern-\initial@hadjust + \kern\initial@leftsep} +% \end{macrocode} +% Now we typeset the initial using |\raisebox| and the values we +% have calculated above. We are as far as typesetting is concerned +% at the place where the text following the initial would +% start. Thus to be able to typeset the initial character we have +% to first back off to the left margin. We do this by placing the +% whole thing inside an |\rlap| so that we do not occupy any +% horizontal space and add a kern of width +% |\parshape@firstlineindent| inside it after the |\raisebox|. This +% will push the initial to the left by the right amount and +% afterwards we are still at the correct point to typeset the text +% following the initial.\footnote{For those who find this +% mysterious, please have a look at the implementation of +% \texttt{\textbackslash parshape@setup} in \texttt{galley2}.} +% \begin{macrocode} + \rlap{ + \raisebox{\initial@raise} + [\initial@height] + [\z@] + {\box\initial@box} + } + \kern\parshape@firstlineindent + } +% \end{macrocode} +% If there is any text that should be treated specially (in +% argument \#3) then we typeset that now otherwise we are done. +% \begin{macrocode} + \IfValueT{#3} + { \initial@textformat{#3} } +} +% \end{macrocode} +% +% \begin{macrocode} +\catcode`\:=12\relax +%</package> +% \end{macrocode} +% +% +% +% +% \subsection{The document commands} +% +% \begin{macrocode} +%<*signature> +\RequirePackage{xinitials} +\RequirePackage{xparse} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% \begin{macro}{\Initial} +% Default document command which takes one mandatory argument (the +% initial) and two optional arguments (any ``quote material'' and +% any text handled specially). +% +% It runs the instance \texttt{initial}/\meta{initial-char} (i.e., +% a different instance per character) if defined or otherwise runs +% the instance \texttt{initial/default}. Thus a class providing +% this command has to define at least the latter instance. +% \begin{macrocode} +\DeclareDocumentCommand \Initial {omo} + { + \IfExistsInstanceTF{initial}{#2} + {\UseInstance{initial}{#2}} + {\UseInstance{initial}{default}} + {#1}{#2}{#3} + } +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\ExtendedInitial} +% An extension of the above document command is the following +% version. This form of |\ExtendedInitial| will support a star +% form, which, if used, expects an optional argument that contains +% key value settings for the \texttt{std} template of type +% \texttt{initial}. It is then followed by three more arguments +% like in the case if the |\Initial| command. If no star is present +% then the optional second argument is interpreted as an instance +% name of type \texttt{initial}. If that instance exist it will be +% used otherwise the instance with name \texttt{default} will be +% used. This way it is possible to place into the mandatory +% argument (argument 4) any character specification including +% accents. +% \begin{macrocode} +\DeclareDocumentCommand \ExtendedInitial {so omo} + { + \IfBooleanTF{#1} + {\UseTemplate{initial}{std}{#2}{#3}{#4}{#5}} + {\IfExistsInstanceTF{initial}{#2} + {\UseInstance{initial}{#2}} + {\UseInstance{initial}{default}} + {#3}{#4}{#5} + } + } +% \end{macrocode} +% \end{macro} +% +% \begin{macrocode} +%</signature> +% \end{macrocode} +% +% \Finale +% diff --git a/Master/texmf-dist/source/latex3/xinitials/xinitials.ins b/Master/texmf-dist/source/latex3/xinitials/xinitials.ins new file mode 100644 index 00000000000..71ab2559e3e --- /dev/null +++ b/Master/texmf-dist/source/latex3/xinitials/xinitials.ins @@ -0,0 +1,13 @@ +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble +\endpreamble + +\generate{% + \file{xinitials.sty}{\from{xinitials.dtx}{package}} + \file{xinitials.sig}{\from{xinitials.dtx}{signature}} + } + +\endbatchfile diff --git a/Master/texmf-dist/source/latex3/xinitials/xinitials.sig b/Master/texmf-dist/source/latex3/xinitials/xinitials.sig new file mode 100644 index 00000000000..4962f090cb6 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xinitials/xinitials.sig @@ -0,0 +1,43 @@ +%% +%% This is file `xinitials.sig', +%% generated with the docstrip utility. +%% +%% The original source files were: +%% +%% xinitials.dtx (with options: `signature') +%% +%% +%% $Header: /usr3/users/latex3/design/consolidation/CURRENT/RCS/xinitials.dtx,v 1.7 2000/01/28 13:39:56 latex3 Exp $ +%% +%% (C) Copyright 1999-2000 Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +\ProvidesFile{xinitials.sig} + [2000/01/28 v0.1h templates for initials] +\RequirePackage{xinitials} +\RequirePackage{xparse} +\IgnoreWhiteSpace +\DeclareDocumentCommand \Initial {omo} + { + \IfExistsInstanceTF{initial}{#2} + {\UseInstance{initial}{#2}} + {\UseInstance{initial}{default}} + {#1}{#2}{#3} + } +\DeclareDocumentCommand \ExtendedInitial {so omo} + { + \IfBooleanTF{#1} + {\UseTemplate{initial}{std}{#2}{#3}{#4}{#5}} + {\IfExistsInstanceTF{initial}{#2} + {\UseInstance{initial}{#2}} + {\UseInstance{initial}{default}} + {#3}{#4}{#5} + } + } +\endinput +%% +%% End of file `xinitials.sig'. diff --git a/Master/texmf-dist/source/latex3/xor/xmarks.dtx b/Master/texmf-dist/source/latex3/xor/xmarks.dtx new file mode 100644 index 00000000000..c8286827ec0 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xmarks.dtx @@ -0,0 +1,956 @@ +% \iffalse +%% +%% (C) Copyright 1999 Frank Mittelbach +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \begin{macrocode} +\def\next#1: #2.dtx,v #3 #4 #5 #6 #7$#8{ +%<*dtx> + \ProvidesFile{#2.dtx} +%</dtx> +%<package>\ProvidesPackage{#2} +%<driver>\ProvidesFile{#2.drv} + [#4 #3 #8 (#6)]} +\next$Id: xmarks.dtx,v 1.6 2000/06/13 20:47:23 latex3 Exp $ + {multiple marks} +% \end{macrocode} +% +%<*driver> + \documentclass{ltxdoc} +% + \begin{document} + \DocInput{xmarks.dtx} + \end{document} +%</driver> +% +% \fi +% +% +% \GetFileInfo{xmarks.dtx} +% +% \title{The \textsf{xmarks} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{FMi} +% \date{\filedate} +% +% \maketitle +% +% \tableofcontents +% +% +% +% \section{Mark algorithm} +% +% To allow for completely independent marks we use the following +% procedure: +% \begin{itemize} +% \item +% For every mark of type \meta{type} we have a queue that holds every mark +% info found in memory. Every info is associated with a unique number, +% i.e., we simply count them. The queue always holds at least one item +% which is the previous mark info, i.e., the last mark for that type on +% the previous page. +% +% \item +% We use \TeX's internal mark mechanism only to record the associated +% numbers for marks for every type on the current page. +% +% \item +% For every \meta{type} we record the info-number that belongs to the last +% mark of the previous page. +% +% \item +% By looking at \TeX's internal |\botmark| we can determine the +% info-number of the last mark for every \meta{type} that is on the current +% page. +% +% \item +% The difference between this number and the info-number from the last +% page gives us the number of marks for every \meta{type} on the current page. +% +% \item +% That way we are able to decide how to extract items from the queue so +% that first, last, and previous mark for every type can be accessed. +% \begin{itemize} +% \item +% If the difference is zero, no new marks have been added on the +% current page, therefore the only item on the corresponding mark type +% queue holds the info that should be previous, first, and last mark of +% this type for the current page. +% \item +% If the difference is one, then the first item in the queue represents +% the info that should become the previous mark (it will be popped off) +% and the second item (which will be kept, since it will become the +% previous mark for the next page) should become first and last mark for +% the current page. +% \item +% Otherwise we had at least two marks for this type on the current page. +% Therefore, the first item in the queue will become previous mark (popped +% off), the second will become first mark (popped off), then we pop off +% all but the last item in the queue, which will become last mark, by only +% looking at it. +% \end{itemize} +% In other words every queue should hold only one item after this part of +% the algorithm has acted. +% After this is done we save the info-numbers given by |\botmark| +% as the info-numbers of the last page, so that they are available next time. +% +% \item +% Putting a mark into the galley therefore means to put its info to the +% right of the corresponding queue, increment the current info-number for +% \meta{type} by one and putting a \TeX{} mark into the galley holding the +% current info-numbers for all \meta{types}. +% +% \end{itemize} +% +% +% \subsection{Restrictions} +% +% One restriction in using this algorithm without further refinements +% is that for every \meta{type} there will be an upper limit of marks allowed +% within one document. This upper limit is given by |\maxdimen| which is +% probably high enough to ignore it, but it could be improved by resetting +% the info numbers whenever all marks have found their way onto the +% current page. +% +% Another restriction is that one better not changes from linearily +% processing the data for the main galley, or, if one modifies that +% processing one needs to carefully adjust the data structures for the +% marks as well. The problem being that the individual marks within a +% preprocessed galley will stay there forever (and thus can be parsed +% several times), the external data structures, e.g., the plists and +% the sequences however need manual corrections in that case. +% +% \subsection{Implementation} +% +% The original implementation was done on a portable PC in a train +% sometime in 1992/93 and is just a straight implementation of the +% above algorithm using plists to hold the current and the last +% info-numbers. The whole stuff could be done much better by analysing +% the algorithm combining common parts (a lot of thing have be done +% twice, etc.) and recoding the rest in a better way. +% +% The implementation below is more or less a straight adaption +% of that code, so it still needs a rewrite one day. It is based on +% modules implementing ``queues'', ``property lists'', and ``quarks'' +% most of which have been published as experimental code with a +% slightly different surface syntax, i.e., as \texttt{l3seq.sty}, +% \texttt{l3prop.sty}, and \texttt{l3quark.sty}. +% +% New stuff: +% \begin{macrocode} +\RequirePackage{ldcsetup} +\IgnoreWhiteSpace +% \end{macrocode} +% +% \begin{macrocode} +\long\def\@firstofthree#1#2#3{#1} +\long\def\@secondofthree#1#2#3{#2} +\long\def\@thirdofthree#1#2#3{#3} +% \end{macrocode} +% +% \begin{macrocode} +\def \tlp@to@str@N {\expandafter \tlp@to@str@aux \meaning} +\def \tlp@to@str@aux #1>{} +\def \tlp@to@str@c #1 {\expandafter \tlp@to@str@N \csname#1\endcsname} +% \end{macrocode} +% +% +% +% +% +% \subsection{Commands for manipulating queues} +% +% \begin{macro}{\trace@queue} +% \begin{macro}{\trace@queue@internal} +% \begin{macro}{\tracingqueues} +% \begin{macrocode} +%<*trace> +\def\trace@queue#1{\ifnum \tracingqueues > \z@ + \typeout{Queues:~ #1~ \on@line}\fi} +\def\trace@queue@internal#1{\ifnum\tracingqueues>\@ne + \typeout{Queues:~ #1~ \on@line}\fi} +\newcount\tracingqueues +%</trace> +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\queue@new@c} +% \begin{macrocode} +\def\queue@new@c#1{\@namedef{#1}{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\queue@gadd@Nn} +% \begin{macrocode} +\def\queue@gadd@Nn#1#2{\expandafter\gdef\expandafter#1\expandafter + {#1\queue@elt#2\queue@eelt} +%<*trace> + \trace@queue@internal{add~ `#2'~ to~ queue~ \string#1} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\queue@gadd@cn} +% \begin{macrocode} +\def\queue@gadd@cn#1{\expandafter\queue@gadd@Nn\csname#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\queue@top@NN} +% \begin{macrocode} +\def\queue@top@NN#1#2{ + \queue@empty@err@N#1 + \expandafter\queue@top@split@w#1\q@stop{\def#2} +%<*trace> + \trace@queue@internal{top~ of~ queue~\string#1:~`\tlp@to@str@N#2'} +%</trace> +} +% \end{macro} +% +% \begin{macro}{\queue@top@split@w} +\def\queue@top@split@w\queue@elt#1\queue@eelt#2\q@stop#3{#3{#1}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\queue@top@cN} +% \begin{macrocode} +\def\queue@top@cN#1{\expandafter\queue@top@NN\csname#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\queue@pop@aux@nnNN} +% \begin{macro}{\queue@pop@aux@w} +% \begin{macrocode} +\def \queue@pop@aux@nnNN #1#2#3{ + \queue@empty@err@N #3 + \expandafter\queue@pop@aux@w #3\q@stop #1#2#3} +\def \queue@pop@aux@w \queue@elt#1\queue@eelt + #2\q@stop #3#4#5#6{#3#5{#2}#4#6{#1}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\queue@gpop@NN} +% \begin{macrocode} +\def \queue@gpop@NN #1#2{\queue@pop@aux@nnNN \gdef \def #1 #2 +%<*trace> + \trace@queue@internal{pop~ of~ queue~\string#1:~`\tlp@to@str@N #2'} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\queue@gpop@cN} +% \begin{macrocode} +\def \queue@gpop@cN #1{\expandafter\queue@gpop@NN\csname#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\queue@empty@err@N} +% \begin{macrocode} +\def\queue@empty@err@N #1{\ifx#1\@empty \ERROR \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% +% +% +% \subsection {Quarks} +% +% A quark is a control sequence that expands into itself@ |\def| +% |\foo{\foo}|. Quarks provide a cheap way of generating distinct +% constants. Also, they permit the following ingenious trick: when +% you pick up a token in a temporary, and you want to know whether you +% have picked up a particular quark, all you have to do is compare the +% temporary to the quark using |\ifx|. +% +% \begin{macro}{\quark@new@N} +% Allocate a new quark. +% \begin{macrocode} +\def \quark@new@N #1{\def #1{#1}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\q@stop} +% \begin{macro}{\q@no@value} +% \begin{macro}{\q@nil} +% |\q@stop| is often used as a marker in parameter text, +% |\q@no@value| is the canonical missing value, and |\q@nil| +% represents a nil pointer in some data structures. +% \begin{macrocode} +\quark@new@N \q@stop +\quark@new@N \q@no@value +\quark@new@N \q@nil +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\q@error} +% \begin{macro}{\q@mark} +% We need two additional quarks. |\q@error| delimits the end of +% the computation for purposes of error recovery. |\q@mark| is +% used in parameter text when we need a scanning boundary that is +% distinct from |\q@stop|. +% \begin{macrocode} +\quark@new@N\q@error +\quark@new@N\q@mark +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\quark@if@no@value@NTF} +% \begin{macro}{\quark@if@no@value@NF} +% \begin{macro}{\quark@if@no@value@nTF} +% \begin{macro}{\quark@if@no@value@nT} +% \begin{macro}{\quark@if@no@value@nF} +% Here we test if we found a special quark as the first argument. +% The argument might contain an arbitrary list of tokens, therefore +% we have to wrap it up in a token list pointer. +% \begin{macrocode} +\def \quark@if@no@value@NTF #1{ +% \end{macrocode} +% We better start with |\q@no@value| as the first argument since +% the whole thing may otherwise loop if |#1| is wrongly given +% a string like |aabc| instead of a single token.\footnote{It may +% still loop in special circumstances however!} +% \begin{macrocode} + \ifx\q@no@value#1 + \expandafter\@firstoftwo + \else \expandafter\@secondoftwo \fi} +% \end{macrocode} +% It would be possible to speed up the following commands by +% providing individual implementations similar to the one above. +% Should perhaps be done if they are used often! +% \begin{macrocode} +\def \quark@if@no@value@NF #1{\quark@if@no@value@NTF {#1}\@empty} +\def \quark@if@no@value@nTF #1{\gdef \@gtempa {#1} + \quark@if@no@value@NTF\@gtempa} +\def \quark@if@no@value@nF #1{\quark@if@no@value@nTF {#1}\@empty} +\def \quark@if@no@value@nT #1#2{\quark@if@no@value@nTF {#1} + {#2}\@empty} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\quark@if@nil@NTF} +% A function to check for the presence of |\q@nil|. +% \begin{macrocode} +\def\quark@if@nil@NTF#1{ + \ifx#1\q@nil + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo\fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Commands for manipulating property lists} +% +% +% \begin{macro}{\prop@new@N} +% \begin{macrocode} +\def \prop@new@N #1{\def #1{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\prop@put@NNn} +% \begin{macro}{\prop@gput@NNn} +% \begin{macro}{\prop@gput@NNo} +% \begin{macro}{\prop@gput@cco} +% \begin{macro}{\prop@gput@ccn} +% \begin{macrocode} +\long\def \prop@put@NNn #1#2{\prop@split@aux@NNn + #1#2{\prop@put@aux@w {\def #1}#2}} +\long\def \prop@gput@NNn #1#2{\prop@split@aux@NNn + #1#2{\prop@put@aux@w {\gdef #1}#2}} +% missing commands for galley stuff... +\def \prop@gput@NNo #1#2#3{ + \expandafter\prop@gput@NNn \expandafter #1 \expandafter + #2 \expandafter { #3 } } +\def \prop@gput@cco #1#2#3{ + \expandafter\prop@gput@NNn \csname #1\expandafter\endcsname + \csname #2\expandafter\endcsname + \expandafter { #3 } } +\def \prop@gput@ccn #1#2{ + \expandafter\prop@gput@NNn \csname #1\expandafter\endcsname + \csname #2\endcsname + } +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\prop@put@aux@w} +% \begin{macrocode} +\long\def \prop@put@aux@w #1#2#3#4#5#6{ + \quark@if@no@value@nTF {#4} + {#1{#2{#6}#3}} + {\def\tmp@w ##1#2\q@no@value {#1{#3#2{#6}##1}} + \tmp@w #5}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\prop@split@aux@NNn} +% \begin{macrocode} +\long\def \prop@split@aux@NNn #1#2#3{ + \def\tmp@w ##1#2##2##3\q@stop {#3{##1}{##2}{##3}} +% ^ ^ needed! + \expandafter\tmp@w #1#2\q@no@value \q@stop} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\prop@get@NNN} +% \begin{macrocode} +\long\def \prop@get@NNN #1#2{\prop@split@aux@NNn + #1#2\prop@get@aux@w} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\prop@get@aux@w} +% \begin{macrocode} +\long\def \prop@get@aux@w #1#2#3#4{\def#4{#2}} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\prop@map@funct@Nn} +% \begin{macrocode} +\let \prop@map@funct@Nn \@gobbletwo +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\prop@map@NN} +% \begin{macrocode} +\def \prop@map@NN #1#2{ + \let \prop@map@funct@Nn #2 + \expandafter\prop@map@aux@w #1\q@stop \q@stop} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\prop@map@aux@w} +% \begin{macrocode} +\def \prop@map@aux@w #1#2{ + \ifx #1\q@stop \else + \prop@map@funct@Nn #1{#2} + \expandafter\prop@map@aux@w + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\prop@map@cN} +% \begin{macrocode} +\def \prop@map@cN #1{ + \expandafter \prop@map@NN \csname #1\endcsname } +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% +% \subsection{Commands for manipulating marks} +% +% +% +% \begin{macro}{\trace@mark} +% \begin{macro}{\trace@mark@internal} +% \begin{macro}{\tracingmarks} +% Tracing is done when |\tracingmarks| is positive. +% \begin{macrocode} +%<*trace> +\def\trace@mark#1{\ifnum \tracingmarks > \z@ + \typeout{Marks:~ #1~ \on@line}\fi} +\def\trace@mark@internal#1{\ifnum\tracingmarks>\@ne + \typeout{Marks:~ #1}\fi} +\newcount\tracingmarks +%</trace> +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\mark@new} +% Defines a new mark label and retrieval token list pointer. +% \begin{macrocode} +\def\mark@new#1{ +%<*trace> + \trace@mark + {new~mark:~\string#1} +%</trace> +% \end{macrocode} +% We make sure that the argument is still free and allocate the +% corresponding queue. To avoid problems with the use of such tlp's +% when they are used before the first |\mark@update@structure| we initialize +% them in a way that |\mark@previous| and the like will accept them even +% then. +% \begin{macrocode} + \newcommand* #1 {{}{}{}} + \queue@new@c{\string#1@seq} +% \end{macrocode} +% The last info-number for this type will be set to |1| This value +% is actually arbitrary and we could use |-\maxdimen+1| to get the +% range doubled. +% \begin{macrocode} + \prop@gput@NNn\mark@last@plist#1{1} +% \end{macrocode} +% More important is that the starting value for the current +% info-number is one less then the one used above. +% \begin{macrocode} + \prop@gput@NNn\mark@curr@plist#1{0} +% \end{macrocode} +% We now put the very first mark of this type in. This mark will be +% empty. This will initialize the queue (now holding the empty previous +% mark) increment the current info number, so that last and current are +% now equal and also puts a \TeX{} mark into the galley will the +% additional type present. +% \begin{macrocode} + \mark@put@Nn#1{}% +% \end{macrocode} +% \begin{macrocode} + \expandafter\g@addto@macro\expandafter\mark@save@state\expandafter{% + \expandafter\global\expandafter\let + \csname saved\string#1@seq\expandafter\endcsname + \csname\string#1@seq\endcsname} + \expandafter\g@addto@macro\expandafter\mark@restore@state@internal\expandafter{% + \expandafter\global\expandafter\let + \csname\string#1@seq\expandafter\endcsname + \csname saved\string#1@seq\endcsname} +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\mark@save@state} +% \begin{macro}{\mark@restore@state@internal} +% Save and restore the current state of the mark data +% structure. The commands will be extended by |\mark@new|. They are +% needed if part of the main galley is being reused or several +% times parsed. +% \begin{macrocode} +\def\mark@save@state{% + \global\let\saved@mark@curr@plist\mark@curr@plist + \global\let\saved@mark@last@plist\mark@last@plist} +\def\mark@restore@state@internal{% + \global\let\mark@curr@plist\saved@mark@curr@plist + \global\let\mark@last@plist\saved@mark@last@plist} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\mark@restore@state} +% |\mark@restore@state| will restore the state of the mark +% mechanism to the one saved by |\mark@save@state|. It has to be +% called inside an output routine and as it needs an output routine +% of its own to restore the |\mark| status of the bottom mark (so +% that \TeX{} correctly updates the mark registers in case it +% doesn't find a mark in box 255) it has an argument which is +% executed inside that output routine to regain control. +% +% The code in the argument has to set |\output| to a new output +% routine! If not you are in trouble. +% +% \begin{macrocode} +\def\mark@restore@state#1{% +%<*trace> + \@tracepush{mark@restore@state} +%</trace> +% \end{macrocode} +% We first restore the external data structures by calling +% |\mark@restore@sate@internal|. Then we have to ensure that \TeX's +% idea of what the current |\botmark| is, corresponds to what it +% was when we saved the state. Back then it was the contents of +% |\mark@last@plist| so we are now adding an empty box and then +% mark with is contents +% onto the MVL followed by a penalty that ensures we trigger the +% output routine and then specify a tiny little output routine +% whose sole purpose is to get that mark processed. +% \begin{macrocode} + \mark@restore@state@internal + \hbox{}% +% \end{macrocode} +% We have to protect |\mark@last@plist| from expanding too far +% inside the |\mark| so we first put it into a token register +% before applying |\mark|. +% \begin{macrocode} + \@temptokena\expandafter{\mark@last@plist}% +%<*trace> + \trace@mark@internal{restoring~ botmark~ \the\@temptokena}% +%</trace> + \mark + {\the\@temptokena} + \penalty-20203\relax +% \end{macrocode} +% We are not setting |\vsize| assuming its positive. So the moment +% we return from the current output routine (we are hopefully in +% right now) we should very very soon find the above penalty and +% then trigger the output routine we are about to define now. +% +% In that output routine we have a quick test for the +% |\outputpenalty| just to ensure that we really grabbed what we +% are supposed to grab. Then we throw away the contents of box 255 +% since all we wanted todo is to get |\botmark| set back to the +% value of our mark above. Finally we execute whatever got passed +% along as argument one to regain control. Since current |\output| +% has a rather funny definition the code in that argument better +% change that back to something that does a little bit more +% typesetting. +% \begin{macrocode} + \global\output{% +%<*trace> + \@tracepush{mark@restore@state@or} +%</trace> + \ifnum-20203=\outputpenalty\else \ERROR \fi + \global\setbox\@cclv\box\voidb@x + #1% +%<*trace> + \@tracepop{mark@restore@state@or} +%</trace> + }% +%<*trace> + \@tracepop{mark@restore@state} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\mark@put@Nn} +% To put a mark into the current horizontal or vertical \TeX{} list +% we first update |\mark@curr@plist| and then put its value into the +% mark without any further expansion. (The code could be +% optimized!) +% \begin{macrocode} +%<-trace>\def\mark@put@Nn#1{% % wtest hack } +%<*trace> +\def\mark@put@Nn#1#2{ + \def\l@tmpa@tlp{#2} + \trace@mark + {set~\string#1~<-~\tlp@to@str@N\l@tmpa@tlp} +%</trace> +% \end{macrocode} +% First we have to update the current info number for this type. The +% code is a bit complicated because we have to get the number from the +% the plist update it and then put it back. If we would keep the numbers +% differently this could be improved, probably at the cost of more macro +% names. +% \begin{macrocode} + \@temptokena\expandafter{\mark@curr@plist} + \prop@get@NNN\mark@curr@plist#1\@tempa +%<*debug> + \ifx\q@no@value\@tempa + \ERROR + \fi +%</debug> + \@tempcnta\@tempa + \advance\@tempcnta\@ne + \expandafter + \prop@gput@NNn\expandafter\mark@curr@plist\expandafter#1\expandafter + {\the\@tempcnta} +% \end{macrocode} +% Now we want to put this plist into a \TeX{} mark. We need a +% one-level expansion, otherwise our pkeys would expand which would +% produce chaos. So we save it in a toks register. +% \begin{macrocode} + \@temptokena\expandafter{\mark@curr@plist} + \mark + {\the\@temptokena} +% \end{macrocode} +% Finally we shouldn't forget to put the info at the right of the +% corresponding queue. +% Without tracing we can omit the second argument to +% this function. +% \begin{macrocode} +%<*trace> + \queue@gadd@cn{\string#1@seq}{#2} +%</trace> +%<-trace> \queue@gadd@cn{\string#1@seq}% +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\mark@put@Nnn} +% \begin{macrocode} +\def\mark@put@Nnn#1#2#3{ + \mark@put@Nn#1{#2#3}} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\mark@update@structure} +% This function is for use in output routines to initialize the marks +% at the beginning. It is only useful after \TeX{} internally has +% updated |\botmark|. +% \begin{macrocode} +\def\mark@update@structure{ +% \end{macrocode} +% We map a function over all keys in |\mark@last@plist|, in other +% words over all types of marks. This routine will set the marks for +% all types. Finally we set the plist |\mark@last@plist| to the +% plist that was stored in |\botmark|, i.e., to the +% info-numbers from this page. +% \begin{macrocode} + \prop@map@NN\mark@last@plist\mark@retrieve@single@Nn + \expandafter\gdef\expandafter\mark@last@plist\expandafter{\botmark} +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\mark@retrieve@single@Nn} +% This function will be mapped over the plist containing the info-numbers +% from the last page. This means that |#1| will be the key (which is +% simply our type token list pointer and |#2| is the value, i.e. the +% info-number from the last page for this type. +% \begin{macrocode} +\def\mark@retrieve@single@Nn#1#2{ +%<*trace> + \trace@mark@internal + {queue~for~\string#1~ before:~`\tlp@to@str@c{\string#1@seq}'} +%</trace> +% \end{macrocode} +% We retrieve the info number for this type from |\botmark| +% and store the difference in |\@tempcnta|. +% \begin{macrocode} + \@temptokena\expandafter{\botmark}% +%<*trace> + \trace@mark@internal{picking~ up~ from~ output~ \the\@temptokena}% +%</trace> + \prop@get@NNN\botmark#1\@tempa +%<*debug> + \ifx\q@no@value\@tempa + \ERROR + \fi +%</debug> + \@tempcnta\@tempa + \advance\@tempcnta-#2\relax +%<*trace> + \trace@mark@internal + {found~\the\@tempcnta\space entries~ for~ \string#1~ + (new~\@tempa;~old~#2)} +%</trace> +% \end{macrocode} +% Then we decide what to do depending on its value. +% We use |\@tempa|, |\@tempb|, and |\@tempc| to +% temporarily hold the previous, first and last mark for this type. +% \begin{macrocode} + \ifcase\@tempcnta +% \end{macrocode} +% If there haven't been any new marks we leave the queue alone, +% peeking only at its top element and using it for all three marks. +% \begin{macrocode} + \queue@top@cN{\string#1@seq}\@tempa + \let\@tempb\@tempa + \let\@tempc\@tempa + \or +% \end{macrocode} +% When there was one mark of this type, we pop one item for the +% previous mark of this type, and use the remaining item for first +% and last mark. +% \begin{macrocode} + \queue@gpop@cN{\string#1@seq}\@tempa + \queue@top@cN{\string#1@seq}\@tempb + \let\@tempc\@tempb + \else +% \end{macrocode} +% If we had more than one mark for this type we pop one mark for the +% previous mark of this type, then pop another mark for the first +% mark of this type, then pop all but the last item and use the last +% item as the last mark of this type, keeping it as before on the +% queue. +% \begin{macrocode} + \queue@gpop@cN{\string#1@seq}\@tempa + \queue@top@cN{\string#1@seq}\@tempb + \@whilenum \@tempcnta>\@ne\do + {\advance\@tempcnta\m@ne + \queue@gpop@cN{\string#1@seq} + \@tempc + } + \queue@top@cN{\string#1@seq}\@tempc + \fi +% \end{macrocode} +% After this process all values for previous, first and last mark for +% this type are found so that we can store them in the tlp +% representing this type for further processing. +% \begin{macrocode} + \@temptokena\expandafter{\@tempa} + \@temptokenb\expandafter{\@tempb} + \@temptokenc\expandafter{\@tempc} + \edef#1{{\the\@temptokena}{\the\@temptokenb}{\the\@temptokenc}} +%<*trace> + \trace@mark + {in~output:~\string#1~->~\tlp@to@str@N#1} +% \end{macrocode} +% At this point the queue should show only one item. +% \begin{macrocode} + \trace@mark@internal + {queue~ for~\string#1~after:~`\tlp@to@str@c{\string#1@seq}'} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@temptokenb} +% \begin{macro}{\@temptokenc} +% \begin{macrocode} +\newtoks\@temptokenb +\newtoks\@temptokenc +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\mark@curr@plist} +% \begin{macro}{\mark@last@plist} +% Here are the allocations for the two plists used. +% \begin{macrocode} +\prop@new@N\mark@curr@plist +\prop@new@N\mark@last@plist +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% +% +% +% \begin{macro}{\mark@get@first@N} +% \begin{macro}{\mark@get@last@N} +% \begin{macro}{\mark@get@previous@N} +% To retrieve the first, last or previous page mark, we +% grap the appropriate value stored in the tlp. The marks are stored +% in the tlp in the order previous, first, last mark. These functions +% should be used only in output routines after |\mark@retrieve| has +% acted, otherwise their value will be wrong. They are all fully +% expandable. +% +% Actually, they may bomb when tracing is included and we have +% material that doesn't work corretly within a write. +% \begin{macrocode} +%<*trace> +\def\mark@get@first@N#1{ + \expandafter\@secondofthree#1 + \trace@mark@internal{use~first~\string#1~=~ + `\expandafter\@secondofthree#1'} +} +\def\mark@get@last@N#1{ + \expandafter\@thirdofthree#1 + \trace@mark@internal{use~ last~ \string#1~ =~ + `\expandafter\@thirdofthree#1'} +} +\def\mark@get@previous@N#1{ + \expandafter\@firstofthree#1 + \trace@mark@internal{use~prev~\string#1~ =~ + `\expandafter\@firstofthree#1'} +} +%</trace> +%<-trace>\def\mark@get@first@N{% +%<-trace> \expandafter\@secondofthree} +%<-trace>\def\mark@get@last@N{% +%<-trace> \expandafter\@thirdofthree} +%<-trace>\def\mark@get@previous@N{% +%<-trace> \expandafter\@firstofthree} +% \end{macrocode} +% above version in trace case doesn't work alway! +% \begin{macrocode} +\def\mark@get@first@N{% + \expandafter\@secondofthree} +\def\mark@get@last@N{% + \expandafter\@thirdofthree} +\def\mark@get@previous@N{% + \expandafter\@firstofthree} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\DeclareMarkType} +% \begin{macrocode} +\def\DeclareMarkType#1{ + \expandafter\mark@new\csname mark@#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\PutMark} +% \begin{macrocode} +\def\PutMark#1{ + \@ifundefined{mark@#1}{\ERROR}{} + \expandafter\mark@put@Nn\csname mark@#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\PreviousMark} +% \begin{macrocode} +\def\PreviousMark#1{ + \expandafter\mark@get@previous@N\csname mark@#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\FirstMark} +% \begin{macrocode} +\def\FirstMark#1{ + \expandafter\mark@get@first@N\csname mark@#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\LastMark} +% \begin{macrocode} +\def\LastMark#1{ + \expandafter\mark@get@last@N\csname mark@#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% \Finale +% +\endinput +% +% $Log: xmarks.dtx,v $ +% Revision 1.6 2000/06/13 20:47:23 latex3 +% docu update +% inlined quarks code +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-alloc.dtx b/Master/texmf-dist/source/latex3/xor/xo-alloc.dtx new file mode 100644 index 00000000000..05250715ccb --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-alloc.dtx @@ -0,0 +1,125 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-alloc.dtx,v 1.4 2000/08/11 07:13:34 latex3 Exp $ +% \end{macrocode} +% +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% |\footins| is FD, should probably move to FE +% +% |\@footins| is FE, should probably go and be replaced by a box and skip allocation +% they don't need to be same number, except for compatibility reasons. +% +% |\@kludgeins| was EA maybe can go, depending on how enlargethispage to be implemented. +% for now, move to FC (which was bx@A +% \begin{macrocode} +\chardef\@kludgeins="FC\relax +\global\dimen\@kludgeins \maxdimen +\global\count\@kludgeins 1000 +\global\dimen\@kludgeins\z@ +\global\skip\@kludgeins\z@ +\global\setbox\@kludgeins\box\voidb@x +% \end{macrocode} +% +% \begin{macrocode} +\insc@unt"FC\relax +% \end{macrocode} +% +% count dimen skip no longer bounded by insertion allocation. +% toks now bounded by insertions. +% \begin{macrocode} +\def\newcount{\alloc@0\count\countdef\@kludgeins} +\def\newdimen{\alloc@1\dimen\dimendef\@kludgeins} +\def\newskip{\alloc@2\skip\skipdef\@kludgeins} +\def\newtoks{\alloc@5\toks\toksdef\insc@unt} +% \end{macrocode} +% +% \begin{macrocode} +\def\newinsert#1{\global\advance\insc@unt \m@ne + \ch@ck4\insc@unt\box + \ch@ck5\insc@unt\toks + \allocationnumber\insc@unt + \global\chardef#1\allocationnumber + \wlog{\string#1=\string\insert\the\allocationnumber}} +% \end{macrocode} +% +% \begin{macrocode} +\newinsert\bx@A +\newinsert\bx@B +\newinsert\bx@C +\newinsert\bx@D +\newinsert\bx@E +\newinsert\bx@F +\newinsert\bx@G +\newinsert\bx@H +\newinsert\bx@I +\newinsert\bx@J +\newinsert\bx@K +\newinsert\bx@L +\newinsert\bx@M +\newinsert\bx@N +\newinsert\bx@O +\newinsert\bx@P +\newinsert\bx@Q +\newinsert\bx@R +% \end{macrocode} +% +% like |\@next| but allocates to list if empty (so doesn't have the +% 4th argument) There is a hidden 3rd argument, picked up by |\@xnext|. +% \begin{macrocode} +\def\@allocating@next#1#2{ + \ifx#2\@empty + \xdef#2{\noexpand\@elt\csname bx@\the\insc@unt\endcsname} + \expandafter\newinsert\csname bx@\the\insc@unt\endcsname + \fi + \expandafter\@xnext #2\@@#1#2} +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} + +% +% \endinput +\endinput +% +% $Log: xo-alloc.dtx,v $ +% Revision 1.4 2000/08/11 07:13:34 latex3 +% added header +% +% Revision 1.3 2000/06/13 20:54:46 latex3 +% made this a dtx file +% +% Revision 1.2 2000/02/22 01:03:55 david +% *** empty log message *** +% +% Revision 1.1 2000/02/22 00:52:52 david +% Initial revision +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-capt.dtx b/Master/texmf-dist/source/latex3/xor/xo-capt.dtx new file mode 100644 index 00000000000..618e22f94d7 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-capt.dtx @@ -0,0 +1,306 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-capt.dtx,v 1.13 2000/08/11 07:14:03 latex3 Exp $ +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% \subsection{Modifying the caption command} +% +% \begin{macro}{\@caption} +% |\caption| just saves its main argument in a token register. It also +% has |\unskip| and |\ignorespaces| to cope with hmode. +% The format of the token register is:\\ +% \marg{type}\marg{number}\marg{caption text}\marg{extra info}\\ +% The \meta{type} is something like `figure', used to generate the +% relevant command names. \meta{number} is the fully expanded version of +% |\the|\ldots. The last group is unused by the current definition +% but extended packages may use it to pass extra information to the +% float handler, as required. +% \begin{macrocode} +\def\caption{\@dblarg{\@caption\float@type}} + +\long\def\@caption#1[#2]#3{% + \unskip +% \end{macrocode} +% We use the old \LaTeX{} interface with |\addcontentsline| for the +% moment.\footnote{FIX!!} +% \begin{macrocode} + \addcontentsline{\csname toc@extension@#1\endcsname}{#1} +% \end{macrocode} +% The counter used is not |#1| but given by (|\foat@counter|) which +% should perhaps be passed along but isn't: +% \begin{macrocode} + {\protect\numberline{\csname the\float@counter\endcsname} + {\ignorespaces #2}} + \global\toks\@currbox{#3} + \ignorespaces + } +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Adding captions to float boxes} +% +% This should really be a template instance. +% Must \emph{copy} the float body in |\this@float@box| +% into |\this@captioned@float| adding the caption text. +% May use |\this@area|, |\this@area@col@number| and other information, to be +% determined \ldots +% +% \begin{macro}{\append@caption@to@float} +% Combine float body and caption of the current float (``this +% float'') and store it in |\this@captioned@float|. +% \begin{macrocode} +\def\append@caption@to@float{ + \typeset@some@floatbox + \this@type\this@area + \this@float@box{\csname caption@\this@type\endcsname} + \this@usercnt\this@caption\this@span@number +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\append@here@caption@to@float} +% Combine float body and caption of the current here float and +% store it in |\this@captioned@float|. +% \begin{macrocode} +\def\append@here@caption@to@float{ + \typeset@some@floatbox + \here@type{h\the\curr@col@count 1} + \here@float@box{\csname caption@\here@type\endcsname} + \here@usercnt\here@caption\here@span@number +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\typeset@this@float@and@caption} +% Combine float body and caption of the current float (``this +% float'') and output it into the current list. +% \begin{macrocode} +\def\typeset@this@float@and@caption{ + \append@caption@to@float + \box\this@captioned@float +} +% \end{macrocode} +% \end{macro} +% +% +% +% \section{Some primitive templates for testing} +% +% prove of concept only --- not even prototype +% +% +% \begin{macro}{\typeset@some@floatbox} +% The macro |\typeset@some@floatbox| take 7 arguments as follows: +% \begin{description} +% \item[type] type of the float to be typeset +% \item[area] area in which to format the float +% \item[floatbody box] box register in which the body of the float +% is stored +% \item[caption heading] fixed text like ``Figure'' +% \item[caption number] caption number of the float +% \item[caption text] caption text of the float +% \item[span count] span count (normally deducable from the area +% but\ldots +% \end{description} +% The first two arguments are used to decide which formatting +% instance to call, the remaining arguments are passed to that +% instance. +% +% The logic is (at the moment) as follows: if a template instance +% (type \texttt{buildfloat}) with the name +% \meta{type}|-|\meta{area}\footnote{The ``here'' areas are +% denoted as \texttt{h}\meta{col}\texttt{1}.} +% is defined then this instance is used, +% otherwise we look if there is an instance with just the name of +% the \meta{area}, otherwise we try an instance with the name +% \meta{type} and if this isn't defined either we try the instance +% named |default|. +% \begin{macrocode} +\def\typeset@some@floatbox#1#2{ % type area + + \IfExistsInstanceTF{buildfloat} + { #1 - #2 } + {\def\use@instance@named{#1 - #2}} + { + \IfExistsInstanceTF{buildfloat} + { #2 } + {\def\use@instance@named{#2}} + { + \IfExistsInstanceTF{buildfloat} + { #1 } + {\let\use@instance@named#1 } % we know this is a token + {\def\use@instance@named{default}} + } + } + \UseInstance{buildfloat}\use@instance@named +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macrocode} +% #1 body box +% #2 fixed text +% #3 counter value +% #4 caption +% #5 span number +\DeclareTemplateType{buildfloat}{5} +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{buildfloat}{centeredabove}{5} + { + body-caption-sep =l [10pt] \belowcaptionskip, + } + { + \DoParameterAssignments + + \@parboxrestore + + \hsize=#5\columnwidth + + \global\setbox\this@captioned@float\vbox{ + \sbox\@tempboxb{#2~ #3:~ #4} + \ifdim \wd\@tempboxb >\hsize + #2~ #3:~ #4\par + \else + \hb@xt@\hsize{\hfil\box\@tempboxb\hfil}% + \fi + \vskip\belowcaptionskip + \centerline{ + \copy#1 + } + \kern\z@ + } + } +% \end{macrocode} +% +% \begin{macrocode} +\newbox\@tempboxb +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{buildfloat}{centeredbelow}{5} + { + body-caption-sep =l [10pt] \abovecaptionskip, + } + { + \DoParameterAssignments + + \@parboxrestore + + \hsize=#5\columnwidth + + \global\setbox\this@captioned@float\vbox{ + \centerline{\copy#1} + \vskip\abovecaptionskip + \sbox\@tempboxb{#2~ #3:~ #4} + \ifdim \wd\@tempboxb >\hsize + #2~ #3:~ #4\par + \else + \hb@xt@\hsize{\hfil\box\@tempboxb\hfil}% + \fi + } + } +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{buildfloat}{bottomright}{5} + { + body-caption-sep =l [10pt] \abovecaptionskip, + } + { + \DoParameterAssignments + + \@parboxrestore + + \hsize=#5\columnwidth + + \global\setbox\this@captioned@float\vbox{ + \@@line{\hss\vbox{\copy#1\kern0pt} + \rlap{ + \hskip\abovecaptionskip +% \end{macrocode} +% rubbish as far as it goes: this should be turned into a real +% template probably using coffins +% \begin{macrocode} + \parbox[b]{\marginparwidth + +(#5\columnwidth-\wd#1)/2}{ + \raggedright + #2~ #3:~ #4 + } + }\hss + } + \kern0pt + } + } +% \end{macrocode} +% +% +% +% \subsection{Some test instances} +% +% \begin{macrocode} +\DeclareInstance{buildfloat}{default}{centeredabove}{} + +\DeclareInstance{buildfloat}{figure}{centeredbelow}{} + +\DeclareInstance{buildfloat}{t31}{bottomright}{} +\DeclareInstance{buildfloat}{t22}{bottomright}{} +\DeclareInstance{buildfloat}{t13}{bottomright}{} +% \end{macrocode} +% +% \endinput +\endinput +% +% $Log: xo-capt.dtx,v $ +% Revision 1.13 2000/08/11 07:14:03 latex3 +% added header +% +% Revision 1.12 2000/08/11 06:47:53 latex3 +% untabify +% +% Revision 1.11 2000/07/19 15:55:53 latex3 +% used \float@type rather than \@captype +% extended buildfloat template to 5 arguments +% +% Revision 1.10 2000/07/10 18:45:23 latex3 +% some normalisation of caption attachment code -- needs more work +% +% Revision 1.9 2000/06/13 20:53:55 latex3 +% docu update +% renamed template type builtfloat to buildfloat +% +% Revision 1.8 2000/05/03 20:16:59 latex3 +% added more arguments to the caption template +% +% Revision 1.7 2000/05/03 20:03:59 latex3 +% fixed typo in macro name +% +% Revision 1.6 2000/05/03 18:52:44 latex3 +% enabling write of toc entries +% adding a prove of concept for caption templates +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-final.dtx b/Master/texmf-dist/source/latex3/xor/xo-final.dtx new file mode 100644 index 00000000000..ad4216ea7a3 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-final.dtx @@ -0,0 +1,1094 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% +% +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-final.dtx,v 1.20 2000/08/11 07:14:09 latex3 Exp $ +% \end{macrocode} +% +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% Update: as of April 3 this now does something reasonable with +% top and bottom floats. The text in between still needs lots of +% attention. No headers/footers/margins/overlays etc etc yet. +% +% There is still a lot of inefficient indirection; this shows where we +% may be able to support more general page-makeup systems. +% +% And not much tracing yet. +% +% \subsection{Text columns} +% +% \begin{macro}{\produce@final@column} +% \begin{macro}{\final@column@with@floats} +% \begin{macro}{\final@column} +% +% This version puts column floats in columns; see below for +% an alternative. It simulates current \LaTeX{} so should not be +% taken as a model for anything useful. +% +% When we remove or modernise this a lot more code from below can go +% too. +% +% \begin{macrocode} +\def\final@column@with@floats { +%<*trace> + \@tracepush{produce@final@column} +%</trace> + \setbox\@outputbox \box\@cclv + + \expandafter + \add@floats@top + \csname area@t1\the\curr@col@count\endcsname + + \ifvoid\footins + \else + \setbox\@outputbox \vbox { + \boxmaxdepth \@maxdepth + \dimen@\dp\@outputbox + \unvbox \@outputbox + \vskip-\dimen@ + \vskip \skip\footins + \color@begingroup + \normalcolor + \footnoterule + \unvbox \footins + \color@endgroup + } + \fi + + \expandafter + \add@floats@bottom + \csname area@b1\the\curr@col@count\endcsname + + \global\setbox\csname col@box@\the\curr@col@count\endcsname + % \vbox { % this should one day become \@colht + \vbox { % this should one day become \@colht + % or else + \@texttop + \dimen@ \dp\@outputbox + \unvbox \@outputbox + \vskip -\dimen@ + \@textbottom + }% + \global \maxdepth \@maxdepth +%<*trace> + \@tracepop{produce@final@column} +%</trace> +} +% \end{macrocode} +% This version does not give special treatment to column floats; it +% simply attachs footnotes and tops/tails. +% +% Probably this should just stuff the main text and footnotes into +% boxes (or a box?) with no extra formatting; all aesthetic handling would +% be done later, when the page is being made-up. +% +% The formatting details are clearly temporary. +% +% \begin{macrocode} +\def\final@column { +%<*trace> + \@tracepush{produce@final@column} +%</trace> + \setbox\@outputbox \box\@cclv + + \ifvoid\footins + \else + \setbox\@outputbox \vbox { + \boxmaxdepth \@maxdepth + \dimen@\dp\@outputbox + \unvbox \@outputbox + \vskip-\dimen@ + \vskip \skip\footins + \color@begingroup + \normalcolor + \footnoterule + \unvbox \footins + \color@endgroup + } + \fi + +% \end{macrocode} +% +% I am not sure if texttop/bottom should survive for long: something +% more spohisictaed is needed these days. This may mean that +% footnotes need better handling too: what makes a complex column +% look good? +% +% \begin{macrocode} + \global\setbox\csname col@box@\the\curr@col@count\endcsname + \vbox { % this should one day become \@colht + % or else + \@texttop + \dimen@ \dp\@outputbox + \unvbox \@outputbox + \vskip -\dimen@ + \@textbottom + }% + \global \maxdepth \@maxdepth +%<*trace> + \@tracepop{produce@final@column} +%</trace> +} +\let \produce@final@column \final@column +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\add@floats@top} +% \begin{macro}{\add@floats@bottom} +% These are now used (if at all) +% only within columns (maybe not best even there). +% +% \begin{macrocode} +\def\add@floats@top #1{ + \ifx#1\@empty + \else + \setbox\@tempboxa \vbox{} + \let \@elt \@comflelt #1 + \setbox\@outputbox \vbox{ + \boxmaxdepth \maxdepth + \unvbox\@tempboxa + \vskip -\pagesetup@float@float@sep + \topfigrule + \vskip \pagesetup@float@text@sep + \unvbox\@outputbox + } + \let\@elt\relax + \release@floats#1 + \fi +} +% \end{macrocode} +% +% \begin{macrocode} +\def\add@floats@bottom#1{ + \ifx#1\@empty + \else + \setbox\@tempboxa \vbox{} + \let\@elt\@comflelt + #1 + \setbox\@outputbox \vbox{ + \unvbox\@outputbox + \vskip \pagesetup@float@text@sep + \botfigrule + \unvbox\@tempboxa + \vskip -\pagesetup@float@float@sep + } + \let\@elt\relax + \release@floats#1 + \fi +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% +% \subsection{Shipout and housekeeping} +% +% +% \begin{macro}{\absolute@page@number} +% \begin{macrocode} +\mathchardef\absolute@page@number\c@page +% \end{macrocode} +% \end{macro} +% +% \begin{macrocode} + +% \end{macrocode} +% +% \begin{macro}{\produce@final@page} +% +% This puts everything to be shipped out into the hbox +% |\page@box| and then ships this out (not quite, see below!). +% +% Probably these two processes should be separated. +% +% At present it does the page-makeup within the shipped out box; +% this should proably be done earlier. +% +% Should the box (or the box-name) be a global +% fixed object (bad;-) or a local parameter (good;-)? +% +% The shipping out is surrounded by considerable housekeeping: +% this version sets up to do the writes and fixes the +% numbering. +% +% \begin{macrocode} +\def\produce@final@page{ +%<*trace> + \@tracepush{produce@final@page} + \tr@ce{final~ page~ output:~ Chris'~ version} +%</trace> + \begingroup % the \endgroup is put in by \aftergroup +% \end{macrocode} +% +% \begin{macrocode} + \@resetactivechars + \@parboxrestore + \let \protect \noexpand +% \end{macrocode}% +% Temp: just puts stuff into lists (which could have been built up +% as floats are placed?). +% \begin{macrocode} + \do@floats + \shipout \hbox { % NOTE: an hbox now! +% \end{macrocode} +% +% \begin{macrocode} + \set@typeset@protect + \aftergroup \endgroup + \aftergroup \set@typeset@protect +% \end{macrocode} +% Making the box can be done outside the shipout. +% \begin{macrocode} + \make@page@box + \box \page@box + } +% \endgroup %% This is _implicitly_ here. +% \end{macrocode} +% +% \begin{macrocode} + \count@\absolute@page@number +%<*trace> + \tr@ce{absolute~page:~\the\absolute@page@number} +%</trace> + \advance\count@\@ne + \global\advance\c@page\@ne + \global\mathchardef\absolute@page@number\count@ +%<*trace> + \@tracepop{produce@final@page} +%</trace> +} + +% \end{macrocode} +% \end{macro} +% +% \subsection{The page box} +% +% \begin{macro}{\mbox@addtopage} +% \begin{macro}{\box@addtopage} +% \begin{macro}{\page@box} +% This should be generalised to add a box to any box (without overcrowding). +% \begin{macrocode} +\newbox \page@box +\def\mbox@addtopage (#1,#2)#3{% +%<*trace> + \tr@ce{box~being~added~to~page:~at~(#1,~#2) + } +%</trace> + \global \setbox\page@box + \hbox { + \unhbox \page@box + \mbox@put (#1,#2) {#3} + } +} +\def\box@addtopage (#1,#2)#3{% + \mbox@addtopage (#1,#2){\box #3} +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\make@page@box} +% +% This adds stuff to a globallly named box; maybe it should be more +% generic. +% +% This is some kind of default example. +% It should be templated. +% +% \begin{macrocode} +\def \make@page@box { +%<*trace> + \@tracepush{make@page@box} + \tr@ce{new style page nake-up} +%</trace> +% \end{macrocode} +% Temp for current header: +% \begin{macrocode} + \mbox@addtopage (\pagebodylefthpos, \headheight) + {page:~\thepage} +% \end{macrocode} +% Then add the float areas, using a list of boxes and positions. +% Probably, the whole thing should be done this way but this may +% not be sensible for simple cases. +% +% Also, some alignments (eg text) may be better handled by the +% use of coffins (which are a very similar, but more complex, +% technology). +% +% First set-up starting point for main text body. +% \begin{macrocode} + \forall@columns { + \expandafter \xdef + \csname stack@level@\the\curr@col@count \endcsname + {\pagebodytopvpos} + } + \stack@top@areas + \add@columns + \stack@bot@areas +%<*trace> + \@tracepop{make@page@box} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{The page box: text columns} +% +% This needs to be a lot more sophisticated in order to make these +% look anything but dreadful. +% +% \begin{macro}{\add@columns} +% \begin{macro}{\add@columns@topstacked} +% \begin{macro}{\add@columns@botaligned} +% +% Several possibilities here: choose one. +% +% One way to do bottom-aligned columns (probably will not +% generalise well): +% \begin{macrocode} +\def \add@columns@botaligned { +%<*trace> + \@tracepush{add@columns@botaligned} +%</trace> + \setlength \@tempdima {\pagebodylefthpos} + \forall@columns { +%<*trace> + \tr@ce{bot~aligned~column~\the\curr@col@count :~% + ht=\expandafter\the\expandafter\ht + \csname col@box@\the\curr@col@count \endcsname,~ + dp=\expandafter\the\expandafter\dp + \csname col@box@\the\curr@col@count \endcsname} +%</trace> +% \end{macrocode} +% Rules will need to be handled separately: where do they go in +% general with spanning floats? +% \begin{macrocode} +% \vrule + \box@addtopage ( \@tempdima, \pagebodybotvpos ) + {\csname col@box@\the\curr@col@count \endcsname} + \setlength \@tempdima {\@tempdima + \columnwidth + \columnsep} +% \vrule + } +%<*trace> + \@tracepop{add@columns@botaligned} +%</trace> +} +% \end{macrocode} +% +% Stacking them at the top: this must be dome immediately after +% stacking the top areas. They are aligned, if possible, at the +% top (the actual top, not necessarily the top text line). +% +% \begin{macrocode} +\def \add@columns@topstacked { +%<*trace> + \@tracepush{add@columns@topstacked} +%</trace> + \gsetmlength \cuur@col@pos {\pagebodylefthpos} + \forall@columns { +%<*trace> + \tr@ce{top~stacked~column~\the\curr@col@count :~% + ht=\expandafter\the\expandafter\ht + \csname col@box@\the\curr@col@count \endcsname,~ + dp=\expandafter\the\expandafter\dp + \csname col@box@\the\curr@col@count \endcsname} + \tr@ce{vsize~for~column~\the\curr@col@count~was:~% + \csname col@ht@ \the\curr@col@count\endcsname} + \tr@ce{lowered~column~\the\curr@col@count~:~% + \csname stack@level@\the\curr@col@count \endcsname + } +%</trace> + \gsetmlength@c {stack@level@\the\curr@col@count} + { \csname stack@level@\the\curr@col@count \endcsname + + \expandafter + \ht \csname col@box@\the\curr@col@count \endcsname + } +% \end{macrocode} +% Vertical rules will need to be handled differentlyy: +% where do they go in general with spanning floats? +% \begin{macrocode} +% \vrule + \box@addtopage ( \cuur@col@pos, + \csname stack@level@\the\curr@col@count \endcsname ) + {\csname col@box@\the\curr@col@count \endcsname} + \gsetmlength \cuur@col@pos { \cuur@col@pos + \columnwidth + \columnsep} +% \vrule + } +%<*trace> + \@tracepop{add@columns@topstacked} +%</trace> +} +\let \add@columns \add@columns@topstacked +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \subsection{The page box: float areas} +% +% \begin{macro}{\t@stack@area} +% \begin{macro}{\b@stack@area} +% +% The 4th argument must be a procedure that fills a box whose number +% is its last argument. This rather bizarre code merely avoids +% a box-register-per-area. +% +% \begin{macrocode} +\def\t@stack@area #1#2#3#4{ +%<*trace> + \@tracepush{t@stack@area} +%</trace> + #4 \@tempboxa +% \end{macrocode} +% First update stacking position for these columns. +% \begin{macrocode} + \@tempcnta #2 + \@tempcntb #3 \relax + \setlength \@tempdimb {\ht\@tempboxa + \dp\@tempboxa} + \loop + \@tempdima \csname stack@level@\the\@tempcntb \endcsname + \advance \@tempdima \@tempdimb + \expandafter + \xdef \csname stack@level@\the\@tempcntb \endcsname + { \the\@tempdima } + \advance \@tempcntb \@ne + \advance \@tempcnta \m@ne + \ifnum \@tempcnta > \z@ + \repeat +% \end{macrocode} +% Calculate horizontal displacement. +% \begin{macrocode} + \setlength \@tempdima + {\pagebodylefthpos - \columndisplacement + \columndisplacement * #3} +% \end{macrocode} +% Add box. +% \begin{macrocode} +%<*trace> + \tr@ce{float~area~box~#1#2#3~~lowered~:~% + \csname stack@level@#3 \endcsname + } +%</trace> + \box@addtopage (\@tempdima,\csname stack@level@#3\endcsname) + \@tempboxa +%<*trace> + \@tracepop{t@stack@area} +%</trace> +} +% \end{macrocode} +% Different order for co-stacking. +% \begin{macrocode} +\def\b@stack@area #1#2#3#4{ +%<*trace> + \@tracepush{b@stack@area} +%</trace> + #4 \@tempboxa +% \end{macrocode} +% Calculate horizontal displacement. +% \begin{macrocode} + \setlength \@tempdima + {\pagebodylefthpos - \columndisplacement + \columndisplacement * #3} +% \end{macrocode} +% Add box. +% \begin{macrocode} + \box@addtopage (\@tempdima,\csname stack@level@#3\endcsname) + \@tempboxa +% \end{macrocode} +% Then update stacking position for these columns. +% \begin{macrocode} + \@tempcnta #2 + \@tempcntb #3 \relax + \setlength \@tempdimb {\ht\@tempboxa + \dp\@tempboxa} + \loop + \@tempdima \csname stack@level@\the\@tempcntb \endcsname + \advance \@tempdima -\@tempdimb + \expandafter + \xdef \csname stack@level@\the\@tempcntb \endcsname + { \the\@tempdima } + \advance \@tempcntb \@ne + \advance \@tempcnta \m@ne + \ifnum \@tempcnta > \@ne + \repeat +%<*trace> + \@tracepop{b@stack@area} +%</trace> +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\stack@top@areas} +% \begin{macro}{\stack@bot@areas} +% +% Use of these is all a bit ad hoc for a particular stacking system. +% +% \begin{macrocode} +\def \stack@bot@areas { + \stack@areas@list b \pagebodybotvpos \pagebox@list@b +} +\def \stack@top@areas { + \stack@areas@list t \pagebodytopvpos \pagebox@list@t +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\stack@areas@list} +% +% |#1| : stacking type (t, b or c at present)\\ +% |#2| : starting position\\ +% |#3| : list name +% +% \begin{macrocode} +\def \stack@areas@list #1#2#3 { +%<*trace> + \@tracepush{stack@areas@list} +%</trace> + \ifx #3 \@empty + \else + \forall@columns { +% \end{macrocode} +% Starting point: +% \begin{macrocode} +% \vrule + \expandafter \xdef + \csname stack@level@\the\curr@col@count \endcsname + {#2} + } +% \end{macrocode} +% Stacking or co-stacking: bottom-up or top-down. +% \begin{macrocode} + \expandafter + \let \expandafter + \p@elt \csname #1@stack@area \endcsname + #3 + \fi +%<*trace> + \@tracepop{stack@areas@list} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\make@area@floats@box} +% +% Format all the floats in a list and store the result in a box register. +% This should be templated. +% +% This could do the file-writing too. +% +% |#1| : area-name\\ +% |#2| : box to be filled +% +% \begin{macrocode} +\def\make@area@floats@box #1#2 { +%<*trace> + \@tracepush{make@area@floats@box} +%</trace> + \setbox #2 \vbox{} +% \let \@elt \@comflelt % Big aaah! + \def \@elt { \typeset@float@in@box {#2} } + \csname area@#1\endcsname +% \end{macrocode} +% Not very pretty yet! But better when decoration +% stuff is used. +% \begin{macrocode} + \let \@elt \relax + \expandafter + \release@floats + \csname area@#1\endcsname +%<*trace> + \@tracepop{make@area@floats@box} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{DECORATIONS} +% Not used at present but something like this is probably needed. +% +% \begin{macrocode} + +\def \box@decorate@bot #1 { + \setbox #1 \vbox{ + \vskip \pagesetup@float@text@sep + \botfigrule + \unvbox #1 + \vskip -\pagesetup@float@float@sep + } +} +\def \box@decorate@top #1 { + \setbox #1 \vbox{ + \unvbox #1 + \vskip -\pagesetup@float@float@sep + \topfigrule + \vskip \pagesetup@float@text@sep + } +} + + +% \end{macrocode} +% \end{macro} +% +% +% \subsection{The page box: margins} +% +% Needed? +% +% \subsection{The page box: headers and footers} +% +% Nothing worth puting here yet. +% +% \subsection{The page box: other} +% +% Maybe should be many subsections: eg overlays. +% +% \subsection{Typesetting captions and float boxes} +% +% All more or less temporary. +% +% \begin{macro}{\@comflelt} +% \begin{macro}{\typeset@float@in@box} +% +% Maybe a bad name but this is probably as generic as it can be at +% present (and one would hate to see the name's demise). +% +% \begin{macrocode} +\def\@comflelt #1 { + \global \let \this@float@box #1 + \expandafter + \extract@this@float@actual@structure \the\toks #1 + \setbox\@tempboxa \vbox { + \unvbox\@tempboxa + \typeset@this@float@and@caption + } + } +% \end{macrocode} +% +% Thus sadly we maybe should move to this, avoiding the use of a +% global variable for parameter passing. +% +% \begin{macrocode} +\def\typeset@float@in@box #1 #2 { + \global \let \this@float@box #2 + \expandafter + \extract@this@float@actual@structure \the\toks #2 + \setbox #1 \vbox { + \unvbox #1 + \typeset@this@float@and@caption + } + } +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\typeset@this@float@and@caption} +% +% This should really be a template instance. +% +% It must be integrated with the generic version of +% |\append@caption@to@float| since they must both do the same thing. +% +% May use |\this@area|, |\this@area@col@number| and other information, +% to be determined \ldots even |\this@caption@action|. +% +% First we disable premature captioning (fascist or what?). +% +% \begin{macrocode} +%<*obsolete> +\let\add@caption@to@float@box \relax +%</obsolete> + +%<*obsolete> +\def \typeset@this@float@and@caption { + \box\this@float@box + \nobreak + \smallskip + \hsize\columnwidth + \this@caption \par + \bigskip + \hrule + \vskip\pagesetup@float@float@sep + } +% Reminder ABOVE ONLY WORKS WITH THIS: +% \def\append@caption@to@float{ +% \global\setbox\this@captioned@float\vbox{ +% \copy\this@float@box +% \smallskip +% \hsize\columnwidth +% \this@caption +% \par\bigskip\hrule} +% } +%</obsolete> +% \end{macrocode} +% \end{macro} +% +% \subsection{Page box lists} +% +% \begin{macro}{\pagebox@area} +% \begin{macro}{\@addto@pagebox@list} +% +% Bad names? +% +% Add the float areas to a page-box list, and specify how to +% process them. This should be templated. The columns could be added +% to this list. +% +% The 2nd argument must at present be a procedure that has two +% arguments and it is expected to fill a box whose number +% is its last argument. This rather bizarre code merely avoids +% a box-register-per-area. +% +% |#1| : area-name +% |#2| : action for each float in area +% |#3| : area-position +% +% \begin{macrocode} +\def\pagebox@area #1#2#3 { +%<*trace> + \@tracepush {pagebox@area} +%</trace> + \expandafter + \let \expandafter + \this@list \csname area@#1\endcsname +%<*trace> + \tr@ce{adding~ floats~ (if any)~ #1~ ==~ `\this@list'~ + to~page~list:~#3 } +%</trace> + \ifx \this@list \@empty + \else + \let \p@elt \relax + \@addto@pagebox@list {#3} + { \p@elt #1 { #2 {#1}} } + \fi +%<*trace> + \@tracepop {pagebox@area} +%</trace> +} +% \end{macrocode} +% Ugh!! Improve? +% \begin{macrocode} +\def \@addto@pagebox@list #1#2 { + \@temptokena \expandafter\expandafter\expandafter + { \csname pagebox@list@#1 \endcsname + #2 + } + \expandafter + \xdef + \csname pagebox@list@#1 \endcsname + { \the\@temptokena } +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \subsection{Magic boxes} +% +% \begin{macro}{\mbox@put} +% \begin{macro}{\box@put} +% \begin{macro}{\copy@put} +% +% Probably move sometime.\footnote{Move?} +% +% These add boxes with the specified visual relative position +% but all-zero dimensions (unlike picture mode where the inner +% boxes have non-zero vertical size). A highly generalised lap-box! +% +% At present these use Don Knuth's left-handed DVI co-ordinate +% system. They could (should?) be changed to a saner system as used +% by \LaTeX{}, Postscript and the rest of the known civilised world +% since Descartes. +% +% \begin{macrocode} +\def\mbox@put (#1,#2)#3{% + \setbox\@tempboxa \hbox { +% \raise #2 % Ugh! Zany y-direction--- + \lower #2 % thanks Don! + \hbox {\kern#1 #3\hss} + } +% \end{macrocode} +% For this application we must zero everything. +% \begin{macrocode} + \wd \@tempboxa \z@ + \ht \@tempboxa \z@ + \dp \@tempboxa \z@ + \box\@tempboxa + } +% \end{macrocode} +% +% \begin{macrocode} +\def\box@put (#1,#2)#3{% + \mbox@put (#1,#2) {\box #3} +} +% \end{macrocode} +% +% \begin{macrocode} +\def\copy@put (#1,#2)#3{ + \mbox@put (#1,#2) {\copy #3} +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \subsection{Move me!} +% +% Stuff for elsewhere; maybe to xo-new right now? +% +% \begin{macro}{\forall@areas} +% \begin{macro}{\def \make@useful@list@aux} +% \begin{macro}{\def \make@useful@list} +% Area list stuff\footnote{Probably move.}. +% +% These should be more generally used/available whatever area lists, +% however impemnted, we end up with. +% +% This list manipulation stuff works only for lists whose elements are +% unexpandable; this could be extended. +% \begin{macrocode} +\def \forall@areas #1 { + \def \area@elt ##1##2##3 { + \def \curr@area {##1##2##3} + \def \curr@pos {##1} + \def \curr@col {##3} + \def \curr@span {##2} + #1 + } + \used@areas@exec +} + +\def \make@useful@list@aux #1#2#3 { + \ifx #1 \relax + \else + \expandafter + \xdef \csname \temp@list@name @exec \endcsname + {\csname \temp@list@name @exec \endcsname \temp@list@elt #1#2#3 } + \expandafter + \make@useful@list@aux + \fi +} +\def \make@useful@list #1 #2 { + \edef \temp@list@name + {\expandafter \@gobble \string #1} + \def \temp@list@elt {#2} + \let #2 \relax + \expandafter + \let \csname \temp@list@name @exec \endcsname \@empty + \expandafter + \make@useful@list@aux #1\relax\relax\relax +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\release@floats} +% +% \begin{macrocode} +\def\release@floats#1{ +% \show #1 + \xdef \@freelist {\@freelist#1} + \global\let#1\@empty +} +% \end{macrocode} +% \end{macro} +% +% More helper functions (some not yet used)\footnote{To be moved}. +% +% Lettings. +% +% \begin{macro}{\let@nc} +% \begin{macro}{\let@cn} +% \begin{macro}{\let@cc} +% \begin{macrocode} +\def \let@nc #1 #2 { + \expandafter + \let \expandafter + #1 \csname #2\endcsname +} +\def \let@cn #1 { + \expandafter + \let \csname #1\endcsname +} +\def \let@cc #1 { + \expandafter + \let@nc \csname #1\endcsname +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% Macrised lengths etc. +% +% \begin{macro}{\setmlength} +% \begin{macro}{\gsetmlength} +% \begin{macrocode} +\def \gsetmlength #1#2 { + \setlength \@tempdima {#2} + \xdef #1 {\the\@tempdima} +} +\def \gsetmlength@c #1#2 { + \setlength \@tempdima {#2} + \expandafter + \xdef \csname #1\endcsname + {\the\@tempdima} +} +\def \setmlength #1#2 { + \setlength \@tempdima {#2} + \edef #1 {\the\@tempdima} +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Really temp stuff} +% +% \begin{macro}{TEMP@KLUDGES} +% Some very temporary (very bad) examples and kludges: +% \begin{macrocode} +\def \do@floats { +%<*trace> + \@tracepush{do@floats} +%</trace> + \make@useful@list \used@areas \area@elt + \let \pagebox@list@t \@empty + \let \pagebox@list@b \@empty + \forall@areas { + \expandafter + \pagebox@area + \expandafter + {\curr@area} \make@area@floats@box {\curr@pos} + } +%<*trace> + \tr@ce{ + pagebox~list:~t~ is~\meaning \pagebox@list@t} + \tr@ce{ + pagebox~list:~b~ is~\meaning \pagebox@list@t} + \@tracepop{do@floats} +%</trace> +} + +% \end{macrocode} +% +% Temp place for these calcs. They should be part of the page layout +% set-up.\footnote{Move?} +% Temp positioning stuff: +% \begin{macrocode} +\AtBeginDocument { +%% vert + \setlength \@tempdima {\headheight + \headsep} + \xdef \pagebodytopvpos {\the\@tempdima} + + \setlength \@tempdima {\@tempdima + \textheight} + \xdef \pagebodybotvpos {\the\@tempdima} + +%% horiz + \setlength \@tempdima {\columnwidth + \columnsep} + \xdef \columndisplacement {\the\@tempdima} + + \def \pagebodylefthpos {\z@} % or whatever?) + +% \show \pagebodytopvpos +% \show \pagebodybotvpos +% +% \showthe \headheight +% \showthe \headsep +% \showthe \textheight +% \showthe \textwidth +% \showthe \columnwidth +} + +% \end{macrocode} +% \end{macro} +% +% \endinput +\endinput +% +% $Log: xo-final.dtx,v $ +% Revision 1.20 2000/08/11 07:14:09 latex3 +% added header +% +% Revision 1.19 2000/07/19 15:56:46 latex3 +% removed \extract@this@float@actual@structure (is now in xo-or awaiting +% normalisation with similar commands) +% +% Revision 1.18 2000/07/10 18:46:11 latex3 +% mainly macro renamings +% +% Revision 1.17 2000/06/16 11:20:40 latex3 +% rename \construct@and@test@col@height to \construct@and@test@col@ht +% rename \construct@and@test@col@heights to \construct@and@test@col@hts +% rename \cl@height1 to \@col@ht@1 (etc) +% +% Revision 1.16 2000/06/13 21:17:32 latex3 +% move setting of \protect so that it works +% +% Revision 1.15 2000/04/12 20:52:39 car2 +% Much tidyng: farewell comflelt! +% +% Revision 1.14 2000/04/06 22:14:00 car2 +% added caption setting +% +% Revision 1.13 2000/04/03 12:09:28 car2 +% alpha version +% +% Revision 1.12 2000/04/03 10:59:31 car2 +% Untidy alpha +% +% Revision 1.11 2000/03/30 21:06:28 car2 +% Chris' alpha-minus version +% +% Revision 1.10 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.9 2000/03/22 15:29:42 latex3 +% some normalisations of names +% +% Revision 1.8 2000/03/09 14:44:31 latex3 +% *** empty log message *** +% +% Revision 1.7 2000/03/05 19:38:12 latex3 +% support multiple columns (6 max right now) +% +% Revision 1.6 2000/02/26 18:25:10 david +% release floats changes +% +% Revision 1.5 2000/02/16 17:34:31 latex3 +% bit of extra tracing to find why columns do not align (no good :-) +% +% Revision 1.4 2000/02/16 13:39:47 latex3 +% added 3col support +% +% Revision 1.3 2000/02/16 10:19:03 latex3 +% better code for adding floats to column (using \pagesetup@float@text@sep and friends) +% +% Revision 1.2 2000/02/13 22:28:10 latex3 +% moved some stuff from xo-or.sty to this file +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-float.dtx b/Master/texmf-dist/source/latex3/xor/xo-float.dtx new file mode 100644 index 00000000000..cc552fe25b0 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-float.dtx @@ -0,0 +1,950 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-float.dtx,v 1.32 2000/08/11 07:14:11 latex3 Exp $ +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% +% \begin{macro}{\@xfloat} +% The start of a float environment. +% Unlike \LaTeXe, now save the float as a horizontal list. +% \begin{macrocode} +\def\@xfloat #1[#2]{% +%<*trace> +\@tracepush{float~environment} +%</trace> + \@nodocument +% #2 is either user suplied or \fps@#1 (from 2e again) + \def \@fps {#2} + \def \float@type {#1} +% \end{macrocode} +% Next line could be inline since it is used only once +% now.\footnote{Change?} +% \begin{macrocode} + \expandafter \let \expandafter + \float@sequence@class \csname sequence@class@#1 \endcsname +% \end{macrocode} +% +% \begin{macrocode} + \expandafter \let \expandafter + \float@counter \csname counter@#1 \endcsname +% \end{macrocode} +% Floats (not caption) increment counter: +% \begin{macrocode} + \refstepcounter\float@counter + \ifhmode + \@bsphack + \fi + \ifinner + \@parmoderr\@floatpenalty\z@ + \else + \@allocating@next\@currbox\@freelist + { +% +% not used any longer: +% +% \global\expandafter\let\csname fps@\the\@currbox\endcsname +% \@fps +% \global\expandafter\let\csname ftype@\the\@currbox\endcsname +% \@captype +% + \global\advance\float@sequence@count\@ne + \expandafter\PutMark\expandafter\float@sequence@class\expandafter{ + \the\float@sequence@count} + \global\toks\@currbox{} + } + \fi +% \end{macrocode} +% +% Save |\@currbox| as an |\hbox|. +% \begin{macrocode} + \global\let\@saved@label\@empty + \global \setbox\@currbox +% \end{macrocode} +% The float body is typeset in a normalised environment, i.e.., we +% reset colour and font. This is followed by a call to +% |\body@|\meta{type} to allow the designer to set up special +% conventions for each float type, e.g., a special font or font +% size or a special colour, etc. +% \begin{macrocode} + \hbox \bgroup\color@begingroup + \normalcolor + \normalfont + \normalsize + \csname body@\float@type \endcsname + \ignorespaces} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@endfloatbox} +% The end of a float environment. +% First finish off the box assignment. Then make a copy in a second box. +% The current code makes use of the fact that the allocated boxes +% are in two continuous runs, |\sbx@offset| apart. +% \begin{macrocode} +\def \@endfloatbox{% + \unskip + \outer@nobreak + \color@endgroup + \egroup + \edef\@tempa{ + \global\toks\@currbox{ + {\the\toks\@currbox}{\SPANCNT} + {\@saved@label} + {\csname the\float@counter \endcsname} + {\@fps} + {\float@type} + {\the\float@sequence@count} + }} + \@tempa +%<*trace> +\tr@ce{\the\toks\@currbox} +%</trace> +% \end{macrocode} +% Simple temporary interface to get here floats for testing. Needs +% replacment!\footnote{FIX!!!} +% \begin{macrocode} + \def\@tempa{h} + \ifx\@fps\@tempa + \setup@here@float + \else + \@cons\@activelist\@currbox + \fi +%<*trace> +\@tracepop{float~environment} +%</trace> +} + +\def\SPANCNT{} %%% do properly one day: David + + +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\float@sequence@count} +% |\float@sequence@count| is the counter used to uniquely refer +% to the floats, it is incremented whenever we encounter a new float. +% \begin{macrocode} +\newcount\float@sequence@count +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\label} +% Modify to save the label string. +% \begin{macrocode} +\def\label#1{\@bsphack + \gdef\@saved@label{#1} + \protected@write\@auxout{}% + {\string\newlabel{#1}{{\@currentlabel}{\thepage}}}% + \@esphack} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \begin{macro}{\DeclareFloatType} +% A float type is an identifier like ``figure'' the defines a class +% (?) of floats of floats which have certain attributes in common, +% e.g., they have the same fixed caption text (e.g. \texttt{Fig}), +% they use the same counter to number the floats, etc. +% +% Setting up a float type is done by declaring an instance of type +% \texttt{floattypesetup} and then executing it. +% \begin{macrocode} +\def\DeclareFloatType#1#2{ + \DeclareInstance{floattypesetup}{#1}{std} + { type-id = #1, #2 } + \UseInstance{floattypesetup}{#1} +} +% \end{macrocode} +% +% For each float type \texttt{TYPE} the following utility macros +% hold important static data. +% +% \DescribeMacro\sequence@class@TYPE +% The |\sequence@class@TYPE| holds the name of the float sequence +% class the float type |TYPE| belongs to. A sequence class contains +% all types which should be placed in order of their call-outs, +% e.g., if type ``figure'' and ``table'' are in the same sequence +% class a table whose call-out is later than that of a figure will +% not be placed before it. If on the other hand these types are in +% different sequence classes such reordering will be undertaken by +% the placement algorithm if feasible. +% +% +% \DescribeMacro\toc@extension@TYPE +% The |\toc@extension@TYPE| holds the file extension to which +% caption information for this type is written, e.g., |lot| for +% tables, or |lof| for figures. If there is the desire to produce +% combined listing one can use the same extension for different +% float types.\footnote{This functionality can alternatively be +% provided by putting all captions into a single external file and +% then ignore certain entries when reading the data back, so it +% might vanish again.} +% +% +% \DescribeMacro\fps@TYPE +% The |\fps@TYPE| holds the default float areas in which this float +% type is allowed to go. By default this is the full list of all +% known areas. By restricting it to a subset of areas it is +% possible to provide special placement arrangements, e.g., tables +% always at the bottom only. +% +% +% \DescribeMacro\caption@TYPE +% The |\caption@TYPE| holds the fixed caption text which is +% displayed together with the caption number, e.g., |Figure|, +% etc. This is passed to the caption formatting instances. +% +% +% \DescribeMacro\counter@TYPE +% The |\counter@TYPE| holds the name of the counter to use for +% numbering the floats of type |TYPE|. It is possible that +% different types share the same counter, i.e., are numbered as a +% single sequence. However in that case one should probably ensure +% that the types belong to a single float sequence class since +% otherwise the numbers within the document might get out of +% sequence. On the other hand it is not required to have floats in +% the same sequence class share a counter; they can be numbered +% independently without problems. +% +% \DescribeMacro\body@TYPE +% The |\body@TYPE| holds the formatting instructions that should be +% applied to the body of each float of type |TYPE|. +% +% \begin{macrocode} +\DeclareTemplateType{floattypesetup}{0} + +\DeclareTemplate{floattypesetup}{std}{0}{ + type-id =n \floattypesetup@id, + sequence-class-id =n \floattypesetup@class@id, + toc-extension =n \floattypesetup@toc@ext, + default-area-list =n \floattypesetup@area@list, + caption-text =n \floattypesetup@caption@text, + numbered-boolean =b @test, + numbered-id =n \floattypesetup@numbered@id, + numbered-within-id =n \floattypesetup@numbered@within@id, + numbered-action =f0 \floattypesetup@numbered@action, + body-decls =f0 \floattypesetup@body@decls, + + } + { +% \end{macrocode} +% Setting up defaults is done (at least in parts) in two steps: +% first we set certain key commands to |\relax| then we run +% |\DoParameterAssignments| and then check if they are still +% |\relax|. If so we set the commands that we really want to +% set. This is necessary because several of them have names that +% contain the float type as part of the name and this type name is +% one of the keys. +% \begin{macrocode} + \let\floattypesetup@class@id\relax + \let\floattypesetup@numbered@id\relax + \let\floattypesetup@numbered@action\relax + \let\floattypesetup@body@decls\relax +% \end{macrocode} +% Now for the defaults we can set directly: +% the |@test| switch is locally used to denote that we want to +% number the floats. +% \begin{macrocode} + \@testtrue % number by default +% \end{macrocode} +% The areas which should be tried for the current type are by +% default all areas, i.e., |\known@areas|; we use |\def| not |\let| +% to allow this list to grow afterwards. +% \begin{macrocode} + \def\floattypesetup@area@list{\known@areas} +% \end{macrocode} +% Default for the fixed caption text is |\@empty|. +% \begin{macrocode} + \let\floattypesetup@caption@text\@empty +% \end{macrocode} +% By default we don't run the float counter within another +% counter. We use |\@empty| to denote this since this is also what +% would be returned from |numbered-within-id=,| which might be +% specified by a user. +% \begin{macrocode} + \let\floattypesetup@numbered@within@id\@empty +% \end{macrocode} +% Everything goes by default to the |.toc| file (which isn't too +% bad if the extended \texttt{xcontents} package is used. +% \begin{macrocode} + \def\floattypesetup@toc@ext{toc} % everything in here by default +% \end{macrocode} +% Now we are ready to look at the designer specifications: +% \begin{macrocode} + \DoParameterAssignments +% \end{macrocode} +% Now for the second step: evaluate what we have: If the +% |sequence-class-id| is not set up, we try to default it to the +% |type-id|: +% \begin{macrocode} + \ifx\floattypesetup@class@id\relax + \let\floattypesetup@class@id\floattypesetup@id + \fi +% \end{macrocode} +% Float numbers are only set up if requested (which is the default). +% \begin{macrocode} + \if@test +% \end{macrocode} +% If the |numbered-id| is not set up, we try to default it to +% the |type-id|:\footnote{This needs fixing since part of the float +% handling assumes there is some counter to step etc. FIX!} +% \begin{macrocode} + \ifx\floattypesetup@numbered@id\relax + \let\floattypesetup@numbered@id\floattypesetup@id + \fi +% \end{macrocode} +% Set up the new counter, if it already exists skip this part: +% \begin{macrocode} + \expandafter\ifx\csname c@\floattypesetup@numbered@id \endcsname + \relax + \ifx\floattypesetup@numbered@within@id\@empty + \newcounter\floattypesetup@numbered@id + \else + \newcounter\floattypesetup@numbered@id + [\floattypesetup@numbered@within@id] + \fi +% \end{macrocode} +% The default display for the float number is ``arabic'', we +% overwrite this only if requested: +% \begin{macrocode} + \ifx\floattypesetup@numbered@action\relax + \else + \global\expandafter\let + \csname the\floattypesetup@numbered@id \endcsname + \floattypesetup@numbered@action + \fi + \fi + \fi +% \end{macrocode} +% +% Low-level environment declaration (allows overwriting since +% figure etc already exists)\footnote{Handle better?} +% \begin{macrocode} + \expandafter + \xdef\csname \floattypesetup@id \endcsname + {\noexpand\@float{\floattypesetup@id}} + \global\expandafter \let \csname end\floattypesetup@id \endcsname + \end@float +% \end{macrocode} +% The remaining bits of the code set up the data structures that +% belong to each float type by linking the macro name containing +% the type in its name (i.e., |\floattypesetup@id|) to the +% corresponding key macro. Theay are otherwise straight forward +% |\let|s. +% +% First for |\sequence@class@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname sequence@class@\floattypesetup@id \endcsname + \floattypesetup@class@id +% \end{macrocode} +% Then |\toc@extension@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname toc@extension@\floattypesetup@id \endcsname + \floattypesetup@toc@ext +% \end{macrocode} +% Then |\fps@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname fps@\floattypesetup@id \endcsname + \floattypesetup@area@list +% \end{macrocode} +% Then |\caption@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname caption@\floattypesetup@id \endcsname + \floattypesetup@caption@text +% \end{macrocode} +% Then |\counter@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname counter@\floattypesetup@id \endcsname + \floattypesetup@numbered@id +% \end{macrocode} +% Then |\body@|\meta{type}: +% \begin{macrocode} + \global\expandafter\let + \csname body@\floattypesetup@id \endcsname + \floattypesetup@body@decls + } +% +% +% +% +% \begin{macro}{\DeclareFloatSequenceClass} +% A float sequence class is a list of float types for which the +% placement algorithm should preserve call-out order even between +% objects with different float type. +% +% For each class we need a corresponding ``mark'' (needed by the +% algorithm) and we need to record the class name in an |\@elt| +% list. +% +% Perhaps this declaration should be implicitly handled by +% |\DeclareFloatType|. It would mean a bit more work for the latter +% but less declarations in the document design!\footnote{Change one +% day!} +% \begin{macrocode} +\def\DeclareFloatSequenceClass#1{ +% \end{macrocode} +% We probably have to check if that class is already +% declared since in that case we have to leave out a couple of +% actions. We assume that this is the case if a mark class is +% already defined for it.\footnote{Do it properly!} +% \begin{macrocode} + \@ifundefined{mark@#1} + { + \DeclareMarkType{#1} +% \end{macrocode} +% Add this to the list of known classes. +% \begin{macrocode} + \@cons\float@classes@list{{#1}} + } + \ErrorAlreadyDefined +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\float@classes@list} +% The list of float classes known in the system. +% \begin{macrocode} +\let\float@classes@list\@empty +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\c@figure} +% \begin{macro}{\c@table} +% Throw away good registers\ldots this is only for testing to allow +% us using the OR together with classes like article that sets up +% figure and table already\footnote{Clean up!} +% \begin{macrocode} +\expandafter\ifx\csname c@figure \endcsname \relax +\else + \let\c@figure\relax % thus new counter will be defined + \let\c@table \relax +\fi +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% +% +% +% +% +% \subsection{Float Placement Control Files} +% +% \begin{macro}{\perhaps@write@placements@to@fpl@file} +% |\perhaps@write@placements@to@fpl@file| writes all float +% placements (except for ``here'' floats) into the |fpl| in case we +% are writing to this file. +% +% By default, don't write fpl files. +% \begin{macrocode} +\let\perhaps@write@placements@to@fpl@file\relax +\let\perhaps@write@to@fpl@file\@gobble +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\perhaps@write@to@fpl@file} +% |\perhaps@write@to@fpl@file| writes its first argument to the +% |fpl| in case we are writing to it. +% +% By default, don't write fpl files. +% \begin{macrocode} +\let\perhaps@write@to@fpl@file\@gobble +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\perhaps@write@placements@to@fpl@file@aux} +% The format for a Float: line in an |fpl| file. Only the sequence +% number (|#7|) is currently used, the rest just helps a human +% reader identify the float. +% \begin{macrocode} +\def\perhaps@write@placements@to@fpl@file@aux#1#2#3#4#5#6#7{ + \@spaces\@spaces Float:~#7~(#6~#4)~[#3]^^J} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\savefloatplacements} +% Declaration to turn on writing of FPL files. +% \begin{macrocode} +\def\savefloatplacements{ + \newwrite\fpl@file + \immediate\openout\fpl@file\jobname.fpl + \def\perhaps@write@to@fpl@file{ + \immediate\write\fpl@file + } + \def\perhaps@write@placements@to@fpl@file{ + \def\@elt{\expandafter + \perhaps@write@placements@to@fpl@file@aux\the\toks} + \perhaps@write@to@fpl@file{ + ^^JPage:~\the\absolute@page@number\space (\the\c@page)^^J +% \end{macrocode} +% +% \begin{macrocode} + \expandafter\@write@areas\used@areas\relax\relax\relax + } + \let\@elt\relax}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@write@areas} +% |\@write@areas| loops through an area list (like |\used@areas|) +% and writes lines for every float, provided that |\@elt| is +% properly set up before. It is used inside a |\write| so needs to +% be expandable! +% \begin{macrocode} +\def\@write@areas#1#2#3{ + \ifx\relax#1 + \else + \expandafter\ifx\csname area@#1#2#3\endcsname\@empty + \else + \@spaces Area:~#1#2#3^^J\csname area@#1#2#3\endcsname + \fi + \expandafter\@write@areas + \fi} +% \end{macrocode} +% Alternate version that writes out all areas even if they don't +% contain any floats. +% \begin{macrocode} +\def\@write@areas#1#2#3{ + \ifx\relax#1 + \else + \@spaces Area:~#1#2#3^^J\csname area@#1#2#3\endcsname + \expandafter\@write@areas + \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\readfloatplacements} +% Similar declaration to read FPC files. The file is read at this +% point up to th efirst Page: line. and the output routine command +% |\float@placement@loop| is redefined to read the FPC info for each page. +% \begin{macrocode} +\def\readfloatplacements{ + \newread\fpc@file + \openin\fpc@file\jobname.fpc\relax + \ifeof\fpc@file + \PackageWarningNoLine{xo} + {No~\jobname.fpc:~using~automatic~float~placement} + \else + \let\get@fpc@page@data\get@fpc@page@data@fpc + \get@fpc@page@data + \let\try@float@pages\relax +% \end{macrocode} +% Next line should go once we implement moving floats in and out of +% ``here'' as then we need to read the file at a different +% place!\footnote{Reimplement!} +% \begin{macrocode} + \let\float@placement@loop\fpc@float@placement@loop + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\fpc@float@placement@loop} +% Version of |\try@float@pages| to use with float placement control file. +% Should be moved to xo-or once it works. +% \begin{macrocode} +\def\fpc@float@placement@loop{ +%<*trace> + \@tracepush{fpc@float@placement@loop} +%</trace> +% \end{macrocode} +% Don't think the the next line has any meaning, so +% removed.\footnote{Old command only did set up best@trial, which +% is later on set to relax anyway. Correct to remove?} +% \begin{macrocode} +% \initialise@best@trial + \get@fpc@page@data + \global\let\best@trial\relax +% \end{macrocode} +% +% \footnote{Do we have to set run@with@floats? Check!} +% \begin{macrocode} + \mark@restore@state{ + \unvcopy\@holdpg + \setup@best@column@or + } +%<*trace> + \@tracepop{fpc@float@placement@loop} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\next@fpc@page} +% The next page for which there is FPC data. Initial value has to be +% a number to |\ifnum|. +% \begin{macrocode} +\let\next@fpc@page\m@ne +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\get@fpc@page@data} +% +% \begin{macrocode} +\let\get@fpc@page@data\relax +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\get@fpc@page@data@fpc} +% get one line of data from an FPC file, calls itself recursively +% so the effect of a call is to get all the lines for the current page +% up to and including the Page: line for the next page for which there +% is data. +% \begin{macrocode} +\def\get@fpc@page@data@fpc{ +%<*trace> +\@tracepush{get@fpc@page@data@fpc} +%</trace> + \let\@nextfpc\relax + \ifnum\next@fpc@page>\absolute@page@number +%<*trace> + \tr@ce{No~ float~ control~ on~ page:~ \the\absolute@page@number} +%</trace> + \else + \ifeof\fpc@file +%<*trace> + \tr@ce{fpc~ file~ended} +%</trace> + \global\let\next@fpc@page\maxdimen + \else + \begingroup + \endlinechar`\ % + \catcode`\ 10\relax + \global\read\fpc@file~to~\@gtempa + \endgroup + \let\@nextfpc\get@fpc@page@data + \ifx\@gtempa\@empty + \else + \expandafter\parse@fpc\@gtempa\relax + \fi + \fi + \fi +%<*trace> +\@tracepop{get@fpc@page@data@fpc} +%</trace> + \@nextfpc +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{parse@fpc} +% If float control files are being read, +% Read the section of the fpc file for this page +% and directly assign floats to the specified areas +% with no trials or checks. +% \begin{macrocode} +\def\parse@fpc#1#2~#3~#4\relax{ + \ifx P#1 +%<*trace> +\tr@ce{Next~page~control:~#3} +%</trace> + \global\mathchardef\next@fpc@page#3\relax + \let\@nextfpc\relax + \else\ifx A#1 +%<*trace> +\tr@ce{Area:~#3} +%</trace> + \setup@this@area{#3} + \let\@nextfpc\get@fpc@page@data + \else\ifx F#1 + \ifx\this@area\fpc@here +% \end{macrocode} +% Should allow moving floats into and out of here status means +% reading before the collecton OR, not after.\footnote{FIX, update, +% extend --- whatever you want to call it.} +% \begin{macrocode} +%<*trace> +\tr@ce{here~float} +%</trace> + \else +%<*trace> +\tr@ce{not~here~float} +%</trace> + \begingroup + \count@#3\relax + \global\let\this@float@box\relax + \let\@elt\extract@float@by@number + \@activelist + \endgroup +% \end{macrocode} +% If a float number is specified and there is not a float of that +% number in the active list, something has gone wrong, either we +% haven't reached the float yet (possible if the new arrangement +% results in the callout being on a later page than specified) or +% we have already assigned this float (which is a bug, either in +% this code, or in the fpc file.) Currently this condition is not +% handled other than by |\ERROR|. If the float is found, assign it +% to the current area (as set by an Area: line in the fpc file. +% \begin{macrocode} + \ifx\this@float@box\relax +%<*trace> + \tr@ce{Float:~#3~not~found} +%</trace> + \edef\fpc@list{\fpc@list#3,\this@area\relax} + \show\fpc@list + \else +%<*trace> + \tr@ce{Float:~#3~is~\this@float@box} +%</trace> +% \end{macrocode} +% Before we add the float, let's do some sanity checks. We allow to +% place a float into an area which is bigger than the float (spans +% more columns) but we complain if the area is smaller. +% \begin{macrocode} + \ifnum \this@area@span@number < + \if!\this@span@number! 1\else % big hack + \this@span@number \fi + \relax + \PackageError{xo} + {Float~ bigger~ than~ target~ area} + {Float~\this@sequence@number\space spans ~ + \this@span@number\space columns,~ + but~ target~ area~ \this@area\space + spans~ only~ \this@area@span@number\space + columns.\MessageBreak + Correct~ the~ data~ in~ file~ \jobname.fpc! + } + \fi +% \end{macrocode} +% We also check if the target area is allowed on the current page +% (it could be the case that the page setup for that page doesn't +% list it in its |area-list| key! +% \begin{macrocode} + \xin@\this@area + \used@areas + \ifin@\else + \PackageError{xo} + {Target~ area~ not~ available~ on~ current~ page} + {Float~ \this@sequence@number\space was~ requested~ to~ + be~ placed~ into~ area~ \this@area,\MessageBreak + but~ this~ + area~ is~ not~ available~ on~ page~ \thepage. + \MessageBreak + Correct~ the~ data~ in~ file~ \jobname.fpc! + } +% \end{macrocode} +% If we can't put it into the requested area we have to put it +% somewhere else. Otherwise a lot of code might break. So we simply +% chose the first area in |\used@area|\footnote{Need a solution if +% the page doesn't allow ``any'' floats! FIX!} +% \begin{macrocode} + \ifx\used@areas\@empty % we have a problem + \RESOLVE + \else + \setup@this@area{\expandafter\@carcube\used@areas\@nil} + \fi + \fi +% \end{macrocode} +% Typeset and attach the caption and adjust the text size for the +% current column. +% \begin{macrocode} + \append@caption@to@float + \construct@and@test@col@hts + \if@test + \ERRORFloatAreaToLarge + \fi +% \end{macrocode} +% We append the float to the area after the above column updates, +% otherwise |\construct@and@test@col@hts| would incorrectly think +% there is already a float present even if we add the first float +% to an area. +% \begin{macrocode} + \let\@elt\relax + \xdef\@freelist{\@freelist\@elt\this@float@box} + \expandafter\@cons\csname area@\this@area\expandafter\endcsname + \this@float@box + \fi + \fi +% \end{macrocode} +% +% Loop to next line. +% \begin{macrocode} + \let\@nextfpc\get@fpc@page@data +% \end{macrocode} +% end of case on type of fpc line. +% \begin{macrocode} + \fi\fi\fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\fpc@here} +% +% \begin{macrocode} +\def\fpc@here{hhh} +% \end{macrocode} +% \end{macro} + +% \begin{macro}{\fpc@list} +% +% \begin{macrocode} +\def\fpc@list{\relax} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\get@float@number} +% could be known as |\@seventhofseven|. +% \begin{macrocode} +\def\get@float@number#1#2#3#4#5#6#7{#7} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\extract@float@by@number} +% Find the float box that has the float with sequence number |\count@|. +% \begin{macrocode} +\def\extract@float@by@number#1{ + \ifnum\expandafter\get@float@number\the\toks#1=\count@ + \def\@currbox{#1} + \expandafter\update@this@float@structure\the\toks#1 + \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \endinput +\endinput +% +% $Log: xo-float.dtx,v $ +% Revision 1.32 2000/08/11 07:14:11 latex3 +% added header +% +% Revision 1.31 2000/08/11 06:48:24 latex3 +% untabify +% +% Revision 1.30 2000/08/11 06:44:00 latex3 +% fix typo in initialization +% +% Revision 1.29 2000/08/04 10:17:28 latex3 +% separate out initialisation of here float +% +% Revision 1.28 2000/07/19 17:14:01 latex3 +% deduce \this@class from \this@type instead of storing it on a per +% float basis +% +% Revision 1.27 2000/07/19 15:53:46 latex3 +% introduced float sequence classes +% cleaned up parts of the code +% added further documentation +% +% Revision 1.26 2000/07/10 18:47:12 latex3 +% macro name renaming +% +% Revision 1.25 2000/06/29 17:16:30 latex3 +% introduced \setup@this@area +% +% Revision 1.24 2000/06/26 15:00:59 latex3 +% docu update +% +% Revision 1.23 2000/06/22 20:07:00 latex3 +% renamed some macros to get them more uniform +% +% Revision 1.22 2000/06/22 10:55:59 latex3 +% Includeed part of David's code (formerly in xo-dpc.sty) for writing +% and reading fpl/fpc files. Not done is moving floats in and out of hhh +% +% Revision 1.21 2000/06/16 11:20:50 latex3 +% rename \construct@and@test@col@height to \construct@and@test@col@ht +% rename \construct@and@test@col@heights to \construct@and@test@col@hts +% rename \cl@height1 to \@col@ht@1 (etc) +% +% Revision 1.20 2000/06/15 15:24:25 latex3 +% implemented new semantics for area names +% +% Revision 1.19 2000/06/13 21:18:02 latex3 +% add some trace guards +% +% Revision 1.18 2000/05/03 18:55:34 latex3 +% pass \theCNT instead of \value{CNT} in the float data structure (we +% might need both one day) +% +% Revision 1.17 2000/04/21 19:11:39 latex3 +% updated here float interface (needs fixing) +% +% Revision 1.16 2000/04/08 10:49:39 latex3 +% first draft support for here floats +% +% Revision 1.15 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.14 2000/03/22 15:30:28 latex3 +% some normalisations of names +% started on spans (tmp version) +% +% Revision 1.13 2000/03/16 10:28:29 latex3 +% partial and full flush working for the first time +% +% Revision 1.12 2000/03/05 19:40:07 latex3 +% support multiple columns (6 max right now) +% moved some float init code into page setup +% +% Revision 1.11 2000/02/26 18:22:59 david +% interface to x-alloc and make changes due to +% deferred float pre-allocation +% +% Revision 1.10 2000/02/21 01:45:23 david +% documentation improvements +% +% Revision 1.9 2000/02/20 00:05:08 david +% use galley, don't discard it (get more pages that way) +% +% Revision 1.8 2000/02/19 23:16:19 david +% Use \construct@and@test@col@height before destroying +% \this@captioned@float, not after... +% +% Revision 1.7 2000/02/19 18:55:44 david +% reading fpc files +% +% Revision 1.6 2000/02/17 22:47:07 david +% *** empty log message *** +% +% Revision 1.5.1.1 2000/02/16 10:39:42 latex3 +% 3cols support added +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-flow-chart.dtx b/Master/texmf-dist/source/latex3/xor/xo-flow-chart.dtx new file mode 100644 index 00000000000..5565a5aa6ad --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-flow-chart.dtx @@ -0,0 +1,153 @@ + +% \iffalse +% $Id: xo-flow-chart.dtx,v 1.5 2000/03/22 15:31:14 latex3 Exp $ +% \fi + +\begin{footnotesize} +\begin{verbatim} + (1) + | + V + \setup@collection@or + | + V + New OR: \collection@or + | + V + \setup@float@placement + + + + \setup@float@placement + | + V +(2)--> \float@placement@loop + | + V + \trial@inner@loop + | + V + <current float successfully placed in previous trial?> + | | + no yes + | | + | | + | V + | \try@next@float <--------------------- + | | | + | | | + | <\@activelist empty?> | + | | | | + | no yes | + | | | | + | | V | + | (get it) \@activelist@empty@action | + | | (= \setup@best@column@or) | + -------------v---------------- | + | | + | | + -----> \select@and@test@next@area | + | | | + | | | + | <still open areas for current float type?> | + | | | | + | yes no---------------(defer float)---------------- + | | | + | (do some tests and perhaps | + | close area this way) | + | | | + | <float allowed on this page/column (according to tests)?> | + | | | | + | yes no---------------(defer float)---------------- + | | + | <current area got closed by any test?> + | | | + | yes no + | | | + -------- V + \pretests@success@action (\setup@grabcolumn@or) + + + + + \setup@grabcolumn@or + | + V + \grabcolumn@loop <-------- + | | + V | + New OR: \grabcolumn@or | + | | + | | + <all cols produced?> | + | | | + yes no------------ + | + (store results of trial) + | + V + \setup@cleanup@or + | + V + New OR: \cleanup@or + | + V + <special outputpenalty reached?> --> (reenter 2) + + + + \setup@best@column@or + | + V + \best@column@loop <------- + | | + V | + New OR: \best@column@or | + | | + <all cols produced?> | + | | | + yes no---------- + | + (produce final page) + | + V + \initialise@next@page + | + V + (try to make float pages) + | + V + \setup@collection@or (reenter 1) + + + +\end{verbatim} +\end{footnotesize} + +\endinput + +% +% $Log: xo-flow-chart.dtx,v $ +% Revision 1.5 2000/03/22 15:31:14 latex3 +% some normalisations of names +% some corrections +% +% Revision 1.4 2000/03/05 19:38:51 latex3 +% more updates -- still wrong +% +% Revision 1.3 2000/02/26 18:27:52 david +% updates (not finished) +% +% Revision 1.4 2000/02/18 19:08:47 car2 +% oops, something else changed! +% +% Revision 1.3 2000/02/18 19:05:04 car2 +% correction: removed a defer +% +% Revision 1.2 2000/02/16 10:20:14 latex3 +% small updates +% +% Revision 1.1 2000/02/16 07:35:47 latex3 +% Initial revision +% + diff --git a/Master/texmf-dist/source/latex3/xor/xo-grid.dtx b/Master/texmf-dist/source/latex3/xor/xo-grid.dtx new file mode 100644 index 00000000000..b1d737358a7 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-grid.dtx @@ -0,0 +1,345 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-grid.dtx,v 1.3 2000/08/11 07:14:20 latex3 Exp $ +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% This package implements grid design on top of \LaTeXe{} by adding +% |\AlignToGrid| in various macros. Nothing else is really needed (or +% so I hope :-) +% +% So far this probably doesn't cover all structures that should, or +% could be handled automatically. +% +% \subsection{Headings} +% +% +% \begin{macro}{\headingsinkage} +% This is a temporary register used to specify the amount of +% sinkage a |\@startsection| heading is allowed if it falls at the +% a column break. In a proper reimplementation of |\@startsection| +% as a template, this should be individually specifiable rather +% than being the same for all headings! +% \begin{macrocode} +\newskip\headingsinkage +\headingsinkage=5pt plus 3pt minus 5pt +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@startsection} +% \begin{macrocode} +\def\@startsection#1#2#3#4#5#6{% + \if@noskipsec \leavevmode \fi + \par + \@tempskipa #4\relax + \@afterindenttrue + \ifdim \@tempskipa <\z@ + \@tempskipa -\@tempskipa \@afterindentfalse + \fi + \if@nobreak + \everypar{}% + \else + \addpenalty\@secpenalty + \addvspace\@tempskipa +% \end{macrocode} +% next lines are pretty horrible but we need something like this +% here (only it could be be done better) +% \begin{macrocode} + \vskip-\headingsinkage + \vskip\saved@topskip + \vskip-\prevdepth + \nointerlineskip + \null + \nobreak + \vskip-\saved@topskip + \vskip\headingsinkage + \fi + \@ifstar + {\@ssect{#3}{#4}{#5}{#6}}% + {\@dblarg{\@sect{#1}{#2}{#3}{#4}{#5}{#6}}}} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\@sect} +% Have to ensure that we don't get the heading itself aligned due +% to a dangling |\AlignToGrid| from a previous structure, so we +% issue a |\IgnoreAlignToGrid| early on. That's the only change for +% this command. +% \begin{macrocode} +\def\@sect#1#2#3#4#5#6[#7]#8{% + \ifnum #2>\c@secnumdepth + \let\@svsec\@empty + \else + \refstepcounter{#1}% + \protected@edef\@svsec{\@seccntformat{#1}\relax}% + \fi + \@tempskipa #5\relax + \IgnoreAlignToGrid + \ifdim \@tempskipa>\z@ + \begingroup + #6{% + \@hangfrom{\hskip #3\relax\@svsec}% + \interlinepenalty \@M #8\@@par}% + \endgroup + \csname #1mark\endcsname{#7}% + \addcontentsline{toc}{#1}{% + \ifnum #2>\c@secnumdepth \else + \protect\numberline{\csname the#1\endcsname}% + \fi + #7}% + \else + \def\@svsechd{% + #6{\hskip #3\relax + \@svsec #8}% + \csname #1mark\endcsname{#7}% + \addcontentsline{toc}{#1}{% + \ifnum #2>\c@secnumdepth \else + \protect\numberline{\csname the#1\endcsname}% + \fi + #7}}% + \fi + \@xsect{#5}} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\@xsect} +% Now after having typeset the heading we need to issue +% |\ObeyAlignToGrid| and make sure that the first line of text gets +% aligned again. And in addition we issue a |\AlignToGrid| inside +% the |\everypar| to align the first text after the heading. Of +% course that mean that we will generate a break point after this +% line and thus might end up up with a heading and only a single +% line afterwards. +% +% This could be fixed by using a ``rspace'' structure as +% implemented in \texttt{xo-or.sty} but this is not added at the +% moment! +% \begin{macrocode} +\def\@xsect#1{% + \ObeyAlignToGrid + \@tempskipa #1\relax + \ifdim \@tempskipa>\z@ + \par \nobreak + \vskip \@tempskipa + \@afterheading + \else + \@nobreakfalse + \global\@noskipsectrue + \everypar{% + \if@noskipsec + \global\@noskipsecfalse + {\setbox\z@\lastbox}% + \clubpenalty\@M + \AlignToGrid + \begingroup \@svsechd \endgroup + \unskip + \@tempskipa #1\relax + \hskip -\@tempskipa + \else + \clubpenalty \@clubpenalty + \everypar{}% + \fi}% + \fi + \ignorespaces} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\@afterheading} +% The other case where we have to add |\AlignToGrid| to the +% |\everypar|. +% \begin{macrocode} +\def\@afterheading{% + \@nobreaktrue + \everypar{% + \if@nobreak + \@nobreakfalse + \clubpenalty \@M + \if@afterindent \else + {\setbox\z@\lastbox}% + \fi + \AlignToGrid + \else + \clubpenalty \@clubpenalty + \everypar{}% + \fi}} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{List structures} +% +% \begin{macro}{\@doendpe} +% Handling of |\everypar| after a list strcture is already strange +% and complicated; here we complicate it even more by adding +% |\AlignToGrid| into its definition(s). +% \begin{macrocode} +\def\@doendpe{\@endpetrue + \def\par{\@restorepar + \everypar{\everypar{}\AlignToGrid}\par\@endpefalse}% + \everypar{{\setbox\z@\lastbox}\everypar{}\AlignToGrid\@endpefalse}% +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\endtrivlist} +% And there is one case in |\endtrivlist| in which |\@doendpe| +% is skipped so we have to set |\everypar| manually +% here.\footnote{Perhaps done in a wrong way, CHECK!} +% \begin{macrocode} +\def\endtrivlist{% + \if@inlabel + \leavevmode + \global \@inlabelfalse + \fi + \if@newlist + \@noitemerr + \global \@newlistfalse + \fi + \ifhmode\unskip \par\fi + \if@noparlist + \everypar{\everypar{}\AlignToGrid} + \else + \ifdim\lastskip >\z@ + \@tempskipa\lastskip \vskip -\lastskip + \advance\@tempskipa\parskip \advance\@tempskipa -\@outerparskip + \vskip\@tempskipa + \fi + \@endparenv + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Math} +% +% \begin{macro}{\displaymath} +% \begin{macro}{\enddisplaymath} +% \begin{macro}{\[} +% \begin{macro}{\]} +% Math is a bit more complicated as with the standard definitions +% we don't regain control after the display. So we change all the +% definitions to use the |\@doendpe| method. This means we have to +% redefine |\[| at al to be a ref to |\displaymath| not the other +% way around as it was done in \texttt{latex.ltx}. +% \begin{macrocode} +\def \displaymath { + \relax\ifmmode + \@badmath + \else + \ifvmode + \nointerlineskip + \makebox[.6\linewidth]% + \fi + $$%%$$ BRACE MATCH HACK + \fi +} +\def \enddisplaymath { + \relax\ifmmode + \ifinner + \@badmath + \else + $$%%$$ BRACE MATCH HACK + \fi + \else + \@badmath + \fi +% \end{macrocode} +% To gain control we end the paragraph and then invoke the |\end| +% mechanism for dealing with par. This gives in certain situations +% slightly different results compared working only with |$$|'s but +% that's life. +% \begin{macrocode} + \par + \@endpetrue % kill parindent if current paragraph continues + \@ignoretrue +} +\def\[{\begin{displaymath}} +\def\]{\end{displaymath}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% +% +% \begin{macro}{\endequation} +% Same change for the end of an equation. +% \begin{macrocode} +\def\endequation{\eqno \hbox{\@eqnnum}$$\par\@ignoretrue + \@endpetrue % kill parindent if current paragraph continues +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\endeqnarray} +% And again the same for the equation array structure. +% \begin{macrocode} +\def\endeqnarray{% + \@@eqncr + \egroup + \global\advance\c@equation\m@ne + $$\par\@ignoretrue + \@endpetrue % kill parindent if current paragraph continues +} +% \end{macrocode} +% \end{macro} +% +% \endinput +\endinput +% +% $Log: xo-grid.dtx,v $ +% Revision 1.3 2000/08/11 07:14:20 latex3 +% added header +% +% Revision 1.2 2000/08/06 19:01:12 latex3 +% fix \prevdepth situation before \@startsection +% +% Revision 1.1 2000/07/30 18:07:22 latex3 +% Initial revision +% +% +% +% +% +% +% +% \begin{macro}{} +% \begin{macrocode} +% \end{macrocode} +% \end{macro} diff --git a/Master/texmf-dist/source/latex3/xor/xo-here.dtx b/Master/texmf-dist/source/latex3/xor/xo-here.dtx new file mode 100644 index 00000000000..189aa2259ae --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-here.dtx @@ -0,0 +1,454 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-here.dtx,v 1.12 2000/08/11 07:14:21 latex3 Exp $ +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% Most of the code in this file is temporary in the sense that the +% interfaces are not fixed or the intended functionality is not fully +% implemented. It is sort of the proof of concept stuff. +% +% +% +% \begin{macro}{\requirespace} +% The |\requirespace| command is an interface function for other +% parts of a a class file. It issues a here point which ensures +% that there is at least |#1| amount of space still available in +% the current column. If not it results in carrying the here point, +% including the previous line(s), to the next column. This could, +% for example, be used by a heading to ensure that there is a +% certain amount of minimal space following it. +% +% The precise (?) definition of ``previous line(s)'' is as follows: +% the internal algorithm will split the so far collected column material +% trying reach the latest possible break point before the here +% point. It is theoretically possible to construct examples where +% \TeX{} decides to take an earlier split point but it is +% guaranteed the the here point is not losing contact with the +% material directly preceeding it (unless a legal breakpoint was +% added in front of it). +% If the here point was added via |\vadjust| in horizontal mode, +% this means that the line immediately before it will be after the +% split (since there will be no other legal break point inbetween). +% \begin{macrocode} +\def\requirespace #1 { + \ifhmode + \@bsphack + \fi + \@next\@currbox\@freelist{}{} +% \end{macrocode} +% We are only interested in the type really: +% \begin{macrocode} + \global\toks\@currbox{{}{} + {} + {} + {} + {rspace} + {} + } + \here@point\@currbox{#1} + \@ignorefalse + \@esphack +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\marginpar} +% The current implementation of the document command |\marginpar| +% is only a proof of concept draft. It doesn't cover the full +% flexibility of the \LaTeXe{} version yet (and perhaps one wants +% even an extension of that). +% \begin{macrocode} +\def\marginpar #1 { + \ifhmode + \@bsphack + \fi + \@next\@currbox\@freelist{}{} + \@savemarbox\@currbox{#1} +% \end{macrocode} +% We are only interested in the type really: +% \begin{macrocode} + \global\toks\@currbox{{}{} + {} + {} + {} + {mpar} + {} + } +% \end{macrocode} +% How far is a marginpar allowed to move past the bottom of the +% text area? Or say it differently: how much space does a marginpar +% need to reserve on the page? +% +% The code below works differently than the \LaTeXe{} one: it will +% move the marginpar including the line it was issued on to the +% next column if its text will otherwise fall more than a +% baselineskip below the page bottom. +% \begin{macrocode} + \@tempdima\ht\@currbox + \advance\@tempdima\dp\@currbox + \advance\@tempdima -\baselineskip % allow to run long + \ifdim\@tempdima< \z@ \@tempdima\z@ \fi + \here@point\@currbox{\the\@tempdima} + \@ignorefalse + \@esphack +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% +% +% \begin{macro}{\typeset@a@marginpar} +% The |\typeset@a@marginpar| code is called when a marginpar is +% finally added to the current page (either in a trial or in the +% final run). +% +% It should be templated! +% +% Current code is only working for two column setup (!) and lacks +% any modification possibilities depending on the final position +% for the marginpar. +% +% \begin{macrocode} +\def \typeset@a@marginpar{ + \kern-\pagedepth + \vtop to\pagedepth{\baselineskip\pagedepth + \lineskip\z@ + \vss + \dimen@\dp\@currbox + \ifnum \curr@col@count = \@ne +% \end{macrocode} +% Since this perhaps only a trial setting we have to |\copy| and +% not to |\box|!\footnote{FIX: Should clear those boxes somewhere +% else to save space!} +% \begin{macrocode} + \llap{\copy\@currbox\kern\marginparsep} + \else + \ifnum \curr@col@count = \col@count + \rlap{\kern\columnwidth\kern\marginparsep\copy\@currbox} + \else + \ERROR-NOT-SUPPORTED + \fi + \fi + \kern-\dimen@ + \null} +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\check@and@typeset@a@here@float} +% +% When we reach |\check@and@typeset@a@here@float| we are trying to +% place a float from the active list into some area and have +% encountered a here point while grabbing the column text for this +% trial placement. In |\check@and@typeset@a@here@float| we check if +% the type of the here point is the same as the current float and +% if so whether or not it would conflict with that trial +% placement. This is the case if +% \begin{itemize} +% \item +% the here float and the float under trial have the same type +% \item +% and their ordering gets out of sync. +% \end{itemize} +% \begin{macrocode} +\def\check@and@typeset@a@here@float{ +%<*trace> + \@tracepush{check@and@typeset@a@here@float} +%</trace> +% \end{macrocode} +% If we don't run with floats then no check are necessary (in fact, +% the checks would produce incorrect results), so we skip them and +% immediately typeset the here float. +% \begin{macrocode} + \ifrun@with@floats +% \end{macrocode} +% If the current float under trial has the same sequence class as the here +% object we have to look at the spatial relationship in more detail. +% \begin{macrocode} + \ifx\here@class\this@class +%<*trace> + \tr@ce{here:~ here@class~ =~ this@class~ =~ \this@class} +%</trace> +% \end{macrocode} +% If the float under trial has a larger sequence number than the +% here float we have to ensure that the area we place it in follows +% the here point, i.e., is either a later column or if it is in the +% same column comes at the bottom. +% \begin{macrocode} + \ifnum \this@sequence@number > \here@sequence@number \relax +%<*trace> + \tr@ce{here:~ target~ area~ should~ be~ after~ here~ point!} +%</trace> +% \end{macrocode} +% Like in the case of checking call-out relations we use the column +% number returned in |\count@| by |calculate@target@fl@column| +% rather than always using the start column of the area. +% \begin{macrocode} + \calculate@target@fl@column + \ifnum \count@ > \curr@col@count +%<*trace> + \tr@ce{OK:~ target~ area column~ later} +%</trace> + \else + \ifnum \count@ = \curr@col@count +%<*trace> + \tr@ce{??:~ target~ area~ target~ column~ identical} +%</trace> +% \end{macrocode} +% So in case we are in the same column at the top we fail the trial. +% \begin{macrocode} + \if t \this@area@type +%<*trace> + \tr@ce{Fail:~ target~ area~ is~ before~ here~ point} +%</trace> + \@failtrue +%<*trace> + \else + \tr@ce{OK:~ target~ area~ is~ after~ here~ point} +%</trace> + \fi + \else +% \end{macrocode} +% And we fail the trial if we tried to place the float into an +% earlier column. +% \begin{macrocode} +%<*trace> + \tr@ce{Fail:~ target~ area~ column~ earlier~ + (\the\count@ < \the\curr@col@count)} +%</trace> + \@failtrue + \fi + \fi +% \end{macrocode} +% If the float sequence number of the current float is smaller than +% the one of the here float then we should always handle it via +% flushing the float out. So the |\else| case is really only there +% for debugging +% \begin{macrocode} +%<*debug> + \else + \tr@ce{here:~ target~ area~ should~ be~ before~ here~ point!} + \ifnum \this@area@col@number > \curr@col@count + \tr@ce{Problem:~ target~ area~ column~ after~ here~ point + (\this@area@col@number > \the\curr@col@count)} + \else + \ifnum \this@area@col@number = \curr@col@count + \tr@ce{??:~ target~ area~ target~ column~ identical} + \if t \this@area@type + \tr@ce{OK:~ target~ area~ is~ before~ here~ point} + \else + \tr@ce{Problem:~ target~ area~ is~ after~ here~ point} + \fi + \else + \tr@ce{OK:~ target~ area~ is~ before~ here~ point} + \fi + \fi +%</debug> + \fi + \fi + \fi + \if@fail +% \end{macrocode} +% If the test above failed we report progress claiming that the +% reason is due to the current float being placed before the here +% float. As mentioned above this should be the only possibility why +% things fail. +% \begin{macrocode} +%<*progress> + \progress@failed{\this@area\space before~here~float~ + (\here@type\space \here@sequence@number)~ + in~ column~ \the\curr@col@count} +%</progress> + \global\curr@col@count\col@count +%<*trace> + \tr@ce{Failed:~ here~ float~ out~ of~ sync} +%</trace> + \else + \typeset@a@here@float + \fi +%<*trace> + \@tracepop{check@and@typeset@a@here@float} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\typeset@a@here@float} +% The |\typeset@a@here@float| is called when a here float is +% finally added to the current page (either in a trial or in the +% final run). +% +% The caption is attached by the usual method where the here +% area is denoted by |h|\meta{col}|1|. This allows to have +% different caption placements depending, for example, on the +% column being near the one of outer margins. +% +% The float is separated from preceeding and following text by the +% current value of |\pagesetup@float@inline@sep| as defined in the +% page setup template plus or minus a certain amount to allow +% grid-based typesetting if desired. +% \begin{macrocode} +\def \typeset@a@here@float{ +% \end{macrocode} +% Attach the caption to the float body and store the result in +% |\this@captioned@float|. +% \begin{macrocode} + \append@here@caption@to@float +% \end{macrocode} +% If we are not doing grid typesetting we simply put +% |\pagesetup@float@inline@sep| before and after the formatted +% float. +% \begin{macrocode} + \ifdim \pagesetup@grid@point@sep = \z@ + \@tempskipa\pagesetup@float@inline@sep + \else +% \end{macrocode} +% Otherwise we have to work a little harder since now we need to +% put exactly the right amount of space before and after the float +% to stay within the grid. So we measure the size of the formatted +% float and store the value in |\@tempdima|. +% \begin{macrocode} + \@tempdima\ht\this@captioned@float + \advance\@tempdima\dp\this@captioned@float +% \end{macrocode} +% To this we add twice |\pagesetup@float@inline@sep| which gives us +% the target size for whole object including surrounding space. +% \begin{macrocode} + \advance\@tempdima\tw@\pagesetup@float@inline@sep +% \end{macrocode} +% Calculate the difference to the nearest grid point\ldots +% \begin{macrocode} + \snap@to@grid \@tempdima \pagesetup@grid@point@sep +% \end{macrocode} +% \ldots and decide which grid point is closest. If the smaller one +% is closer use it if we are allowed to shrink the white space by +% the necessary amount. +% \begin{macrocode} + \ifdim \returned@lower@delta@size < \returned@delta@size \relax + \ifdim \returned@lower@delta@size < 2\pagesetup@float@inline@shrink +% \end{macrocode} +% Note that for the lower delta size we have to use the +% negation since we want to backup by this amount and delta sizes +% are always given in absolute values. +% \begin{macrocode} + \xdef \returned@delta@size {-\returned@lower@delta@size } + \fi + \fi +% \end{macrocode} +% Now set up the amount of white space we need around the float by +% starting with the |\returned@delta@size| divided by two (i.e., +% equal amount contributed to both sides of the float and then add +% |\pagesetup@float@inline@sep|. Notice, that we used a skip +% register for the calculation so that any minus or plus parts will +% survive. This is useful in case we are not doing grid typesetting +% and want to allow for some flexibility.\footnote{This needs perhaps +% rethinking it the light of extended grid implementation concept!} +% \begin{macrocode} + \@tempskipa \returned@delta@size \relax + \divide \@tempskipa \tw@ + \advance \@tempskipa \pagesetup@float@inline@sep +%<*trace> + \tr@ce{GRID:~ here~float:~ use~ \the\@tempskipa \space above~ and~ below} +%</trace> + \fi +% \end{macrocode} +% Finally typeset the float and its surrounding space which is by +% now stored in |\@tempskipa|.\footnote{Perhaps make the space +% above and below specifiable individually. One day, perhaps!} +% \begin{macrocode} + \vskip\@tempskipa + \box\this@captioned@float + \vskip\@tempskipa +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setup@here@float} +% Absolutely temp!!!!!\footnote{FIX!!!!} +% \begin{macrocode} +\def \setup@here@float { + \@tempskipa 2\pagesetup@float@inline@sep %FMi arbitrary value TMP + \advance\@tempskipa\ht\@currbox %FMi arbitrary value TMP + \advance\@tempskipa\dp\@currbox %FMi arbitrary value TMP + \advance\@tempskipa5\baselineskip %FMi arbitrary value TMP + \here@point\@currbox{\the\@tempskipa} +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \endinput +\endinput +% +% $Log: xo-here.dtx,v $ +% Revision 1.12 2000/08/11 07:14:21 latex3 +% added header +% +% Revision 1.11 2000/08/04 10:19:09 latex3 +% added init of here floats (temp version) +% +% Revision 1.10 2000/07/19 16:05:41 latex3 +% introduced float sequence class concept +% +% Revision 1.9 2000/07/10 19:13:34 latex3 +% template here floats and support grid typesetting for them. +% +% Revision 1.8 2000/06/29 17:18:44 latex3 +% introduced \setup@this@area +% +% Revision 1.7 2000/06/18 14:58:32 latex3 +% use \calculate@target@fl@column to determine the target column ti +% check if here float and current float are in sync +% +% Revision 1.6 2000/06/15 15:23:05 latex3 +% untabify +% +% Revision 1.5 2000/06/13 20:45:47 latex3 +% docu updates +% +% Revision 1.4 2000/05/03 18:58:56 latex3 +% provide caption template support +% +% Revision 1.3 2000/04/27 19:51:45 latex3 +% bug fix: need to copy boxes in trials :-) +% moved \check@and@typeset@a@here@float to this file +% +% Revision 1.2 2000/04/21 19:01:13 latex3 +% added documentation +% +% Revision 1.1 2000/04/21 10:19:07 latex3 +% Initial revision +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-new.dtx b/Master/texmf-dist/source/latex3/xor/xo-new.dtx new file mode 100644 index 00000000000..acbeda1bf83 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-new.dtx @@ -0,0 +1,701 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-new.dtx,v 1.25 2000/08/11 07:14:23 latex3 Exp $ +% \end{macrocode} +% +% This package is available for test overwrites that need integration +% into the main packages at some point +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% + +% +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% +% STUFF THAT CHANGES CHRIS' xo-final +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% +% +% +% \begin{macrocode} + +\flushbottom + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%changes to xo-final +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\iftrue % using Frank's changes built on 1.15 + +%<*obsolete> +\def\typeset@this@float@and@caption{ + \append@caption@to@float + \box\this@captioned@float +} +%</obsolete> + + + +\def\final@column { +%<*trace> + \@tracepush{produce@final@column} +%</trace> + \setbox\@outputbox \box\@cclv + + \ifvoid\footins + \else + \setbox\@outputbox \vbox { + \boxmaxdepth \@maxdepth +% \end{macrocode} +% \TeX\ calculates page breaks expecting the depth of the main text +% to extend below the page baseline, not contributing to the page height, +% and it assumes the entire height plus depth of footnotes will contribute +% to the page height. When the page is assembled, the footnote depth +% is below the baseline and the main text depth appears mid-page. To +% make the contents fit the page precisely, we (locally) adjust the +% footnote spacing \cs{skip}\cs{footins} by the \emph{difference} in +% the two depths.\footnote{This part of the code was suggested by +% Donald Arseneau in bug report pr3189.} +% \begin{macrocode} + \advance\skip\footins -\dp\@outputbox % already limited to \@maxdepth + \unvbox \@outputbox + \advance\skip\footins + \ifdim\dp\footins>\@maxdepth \@maxdepth \else \dp\footins \fi + \vskip \skip\footins +% \end{macrocode} +% If we are doing grid typesetting we put all excess space between +% the text and the footnote(s). +% \begin{macrocode} + \ifdim \pagesetup@grid@point@sep > \z@ + \vfil + \fi + \color@begingroup + \normalcolor + \footnoterule + \unvbox \footins + \color@endgroup + } + \fi +% \end{macrocode} +% +% I am not sure if texttop/bottom should survive for long: something +% more spohisictaed is needed these days. This may mean that +% footnotes need better handling too: what makes a complex column +% look good? +% +% \begin{macrocode} + \global\setbox\csname col@box@\the\curr@col@count\endcsname + \vbox to \csname col@ht@ \the\curr@col@count\endcsname %<----- + { % this should one day become \@colht + % or else + \@texttop + \dimen@ \dp\@outputbox + \unvbox \@outputbox + \vskip -\dimen@ + \@textbottom + }% + \global \maxdepth \@maxdepth +%<*trace> + \@tracepop{produce@final@column} +%</trace> +} +\let \produce@final@column \final@column + + + +\def\make@area@floats@box #1#2 { +%<*trace> + \@tracepush{make@area@floats@box} + \tr@ce{Area:~ #1} +%</trace> + \@ifundefined{area@#1} % test only needed because of missing integration + { +%<*trace> + \tr@ce{Area:~ not~ set~ up} +%</trace> + } + { + \setup@this@area{#1} % needed below when typesetting floats + + \setbox #2 \box\voidb@x % <-------- FMi +% \let \@elt \@comflelt % Big aaah! + \def \@elt { \typeset@float@in@box {#2} } + \csname area@#1\endcsname +% \end{macrocode} +% Not very pretty yet! But better when decoration +% stuff is used. +% \begin{macrocode} + \let \@elt \relax + + \expandafter + \release@floats + \csname area@#1\endcsname + } +%<*trace> + \@tracepop{make@area@floats@box} +%</trace> +} + + +\def\typeset@float@in@box #1 #2 { +%<*trace> + \@tracepush{typeset@float@in@box} +%</trace> + \gdef\this@float@box {#2} % <------------- FMi + \expandafter + \extract@this@float@actual@structure \the\toks #2 + + \update@this@area@columns + { + \expandafter + \gdecrement@num + \csname col@ \this@area@type + @floats@ \the\count@ @number\endcsname +%<*trace> + \tr@ce{col@ \this@area@type + @floats@ \the\count@ @number~ <-~ + \csname col@ \this@area@type + @floats@ \the\count@ @number\endcsname} +%</trace> + } + + \setbox #1 \vbox { + \ifvoid #1 +%<*trace> +\tr@ce{add~to~#1:~float~ #2} +%</trace> + \else % experimental FMi +%<*trace> +\tr@ce{add~to~#1:~float~ #2~ plus~ \pagesetup@float@float@sep} +%</trace> + \unvbox #1 % experimental FMi + \vskip \pagesetup@float@float@sep % experimental FMi + \fi % experimental FMi + \typeset@this@float@and@caption + } +%<*trace> + \@tracepop{typeset@float@in@box} +%</trace> + } + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% my new xo-final stuff +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +\def \myfinalpage { + \mbox@addtopage (\pagebodylefthpos, -\headsep) + {page:~\thepage} +% \end{macrocode} +% +% \begin{macrocode} +% Init |\dimen|1,2,3,\ldots as vertical current point per column +% (don't forget in Chris's (sorry, Don's) universum zero is at the +% top). +% \end{macrocode} +% +% \begin{macrocode} + \forall@columns{ + \dimen \the\curr@col@count + \z@ + } +% \end{macrocode} +% Now mount all top areas looping through an ordered list of top +% areas. +% \begin{macrocode} + \expandafter\mount@top@areas@loop + \top@areas + \relax\relax\relax +% \end{macrocode} +% Next mount the text columns. +% \begin{macrocode} + \forall@columns{ + +%<*trace> + \tr@ce{GRID (delta):~ column~\the\curr@col@count t:~ + \csname col@t@delta@ \the\curr@col@count + \endcsname\space used} +%</trace> + \advance \dimen \the\curr@col@count + by %NEEDED!!!!! + \csname col@t@delta@ \the\curr@col@count \endcsname + + \advance \dimen \the\curr@col@count + \csname col@ht@ \the\curr@col@count \endcsname + + \setlength \@tempdima + {\pagebodylefthpos - \columndisplacement + + \columndisplacement * \curr@col@count } + + \mbox@addtopage ( \the\@tempdima ,\the\dimen\curr@col@count ) + { \box \csname col@box@ \the\curr@col@count \endcsname } + +%<*trace> + \tr@ce{GRID (delta):~ column~\the\curr@col@count b:~ + \csname col@b@delta@ \the\curr@col@count + \endcsname\space used} +%</trace> + \advance \dimen \the\curr@col@count + by %NEEDED!!!!! + \csname col@b@delta@ \the\curr@col@count \endcsname + } +% \end{macrocode} +% Then mount the bottom floats. +% \begin{macrocode} + \def\col@of@focus{0} % temp solution see below + \expandafter\mount@bot@areas@loop + \bot@areas + \relax\relax\relax +% \end{macrocode} +% +% Next thing is absolutely temp: mount a marginal area on the right +% (bottom) to allow footnotes there (this is just for testing). +% \begin{macrocode} + \setlength \@tempdima + {\pagebodylefthpos + \columndisplacement * \col@count } + \mbox@addtopage ( \the\@tempdima , \textheight ) + { \box \saved@footins } % TEMP FMi +% +% Next thing is absolutely temp: mount a marginal area on the right +% (bottom) to allow marginal floats there (this is just for testing). +% \begin{macrocode} + \expandafter + \ifx\csname area@m1\the\curr@col@count\endcsname\relax + \else + \curr@col@count\col@count + \advance\curr@col@count\@ne + \make@area@floats@box {m\the\curr@col@count1}\@tempboxa + \setlength \@tempdima + {\pagebodylefthpos + \columndisplacement * \col@count } + \mbox@addtopage ( \the\@tempdima , \textheight ) + { \vbox to\textheight{\vfil \unvbox \@tempboxa \vfil }} + \fi +% + \ifShowGrid + \ifdim \pagesetup@grid@point@sep > \z@ + \@tempcnta\textheight + \@tempcntb\topskip + \advance\@tempcnta -\@tempcntb + \@tempdimb\pagesetup@grid@point@sep + \@tempcntb\@tempdimb + \divide\@tempcnta\@tempcntb + \advance\@tempcnta\@ne + + \setlength \@tempdimb + {\pagebodylefthpos + \columndisplacement * \col@count + - \columnsep } + \count@\@tempdimb + + \sbox\grid@box{ + \setlength\unitlength{1sp} + \begin{picture}(0,0) + \multiput(0,0)(0,\@tempcntb){\@tempcnta} + {\line(1,0){\count@}} + \end{picture} + } + + \mbox@addtopage ( 0pt ,\textheight ) + { \box\grid@box } + + \fi + \fi +} + +\newbox\grid@box + +\newif\ifShowGrid +\ShowGridtrue + +% for tracing only (unchanged) + + +\def\mbox@addtopage (#1,#2)#3{% +% \tr@ce{box~being~added~to~page:~at~(#1,~#2) } + \global \setbox\page@box + \hbox { + \unhbox \page@box + \mbox@put (#1,#2) {#3} + } +} + + + + +\def\mount@top@areas@loop#1#2#3{ + \ifx#1\relax + \else + \mount@top@area#1#2#3 + \expandafter\mount@top@areas@loop + \fi} + + +\def\mount@top@area#1#2#3 { + \make@area@floats@box {#1#2#3}\@tempboxa + + \ifvoid \@tempboxa + \else + + \setlength \@tempdimb + { \dimen#2 + \ht\@tempboxa + \dp\@tempboxa } + + \setlength \@tempdima + {\pagebodylefthpos - \columndisplacement + \columndisplacement * #2 } + + \mbox@addtopage ( \the\@tempdima ,\the\@tempdimb ) + { \box \@tempboxa } + + \count@ #2\relax + \advance\count@ #3\relax + \loop + \advance\count@\m@ne + \dimen \count@ = \@tempdimb + \advance\dimen \count@ + \ifnum \csname col@t@floats@ \the\count@ @number\endcsname > \z@ + \pagesetup@float@area@sep + \else + \pagesetup@float@text@sep + \fi + \ifnum #2 < \count@ + \repeat + + \fi +} + +\def\mount@bot@areas@loop#1#2#3{ + \ifx#1\relax + \else + \mount@bot@area#1#2#3 + \expandafter\mount@bot@areas@loop + \fi} + +\def\mount@bot@area#1#2#3 { + \make@area@floats@box {#1#2#3}\@tempboxa + + \ifvoid \@tempboxa + \else + + \setlength \@tempdimb + { \dimen#2 + \ht\@tempboxa + \dp\@tempboxa } + +% \end{macrocode} +% There are probably much better ways to get the spacing right, the +% one below is really only a temporary fix: in |\col@of@focus| we +% remember the last column in which already applied +% |\pagesetup@float@text@sep|, any additional float area will +% contribute another |\pagesetup@float@area@sep| +% instead.\footnote{To make this work it is absolutely necessary +% that the floats in bot@areas are ordered by column!!! No-good. FIX!!} +% \begin{macrocode} + \ifnum \col@of@focus < #2 \relax + \def\col@of@focus{#2} + \advance\@tempdimb + \pagesetup@float@text@sep + \else + \advance\@tempdimb + \pagesetup@float@area@sep + \fi + + \setlength \@tempdima + {\pagebodylefthpos - \columndisplacement + \columndisplacement * #2 } + + \mbox@addtopage ( \the\@tempdima ,\the\@tempdimb ) + { \box \@tempboxa } + +% \end{macrocode} +% Next loop is actually not necessary as long we keep the +% restriction that we don't allow partial overlapping float areas, ie we +% will never mount another float area in the columns that are +% spanned by the current float area (other than potentially the +% first and we set this one explicitly). +% \begin{macrocode} + \dimen #2 = \@tempdimb +% \count@ #2\relax +% \advance\count@ #3\relax +% \loop +% \advance\count@\m@ne +% \dimen \count@ = \@tempdimb +% \ifnum #2 < \count@ +% \repeat + + \fi +} + + +% of course \top@areas and \bot@areas should be constructed +% automatically when preparing the \use@areas or from the \known@areas +% but for now i simply define them here: + +\def\top@areas{t13 t12 t22 t32 t11 t21 t31} + +\def\bot@areas{b11 b12 b13 b21 b22 b31 b32} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%% +% next line activates my version (well some of it is activated already +% above) +%%%%%%%%%%%%%%%%%%%%%%%%%%% +\let\make@page@box\myfinalpage + +\fi % end of stuff modifying xo-final 1.15 + +% \end{macrocode} +% + +\endinput + + + +% \begin{macro}{\savecolumnsizes} +% Declaration to turn on writing of CSL (column size list) files. +% \begin{macrocode} +\def\savecolumnsizes{ + \newwrite\csl@file + \immediate\openout\csl@file\jobname.csl + \def\perhaps@write@to@csl@file{ + \immediate\write\csl@file + } + \def\perhaps@write@placements@to@csl@file{ + \def\@elt{\expandafter + \perhaps@write@placements@to@csl@file@aux\the\toks} + \perhaps@write@to@csl@file{ + ^^JPage:~\the\absolute@page@number\space (\the\c@page)^^J +% \end{macrocode} +% +% \begin{macrocode} + \expandafter\@write@areas\used@areas\relax\relax\relax + } + \let\@elt\relax}} +% \end{macrocode} +% \end{macro} +% + + + + + + +\endinput + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% an attempt to use column 0 and n+1 as marginal areas +% not active +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% \begin{macro}{\forall@columns@and@margins} +% \begin{macrocode} +\def\forall@columns@and@margins#1{ + \edef\saved@curr@col@count{\the\curr@col@count} + \global\curr@col@count\col@count + \global\advance\curr@col@count\@ne + \@whilenum \curr@col@count>\m@ne \do + { + #1 + \global\advance\curr@col@count\m@ne + } + \global\curr@col@count\saved@curr@col@count\relax +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macrocode} +% original macro no longer used +\def\initialise@best@trial{ +%<*trace> + \@tracepush{initialise@best@trial} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \global\let\best@trial\@empty + \forall@columns@and@margins{ + \expandafter + \g@addto@macro\expandafter\best@trial\expandafter + { + \expandafter + \global + \csname col@ht@ \the\curr@col@count\endcsname + \textheight + } + } +%<*trace> + \tr@ce{\meaning\best@trial} + \@tracepop{initialise@best@trial} +%</trace> +} +% \end{macrocode} +% + +% \begin{macrocode} +\expandafter\newdimen\csname col@ht@ 0\endcsname +% \end{macrocode} +% + + +% \begin{macro}{\initialise@next@page} +% Initialises the column heights to text height. Clear the float +% area lists, zero holdinginserts to allow footnote texts to arrive +% in the insertion box. +% \begin{macrocode} +\def\initialise@next@page{ +%<*trace> + \@tracepush{initialise@next@page} +%</trace> +% + \forall@columns@and@margins + {\global\csname col@ht@ \the\curr@col@count\endcsname\textheight} +% + \initialise@areas +% + \global\page@float@count\z@ +% + \initialise@best@trial +% \end{macrocode} +% +% \begin{macrocode} + \initialise@flush@data +% \end{macrocode} +% +% \begin{macrocode} + \initialise@here@data +% \end{macrocode} +% +% \begin{macrocode} + \initialise@footins@action +% \end{macrocode} +% +% Nothing is closed when we are at the start of a page. +% \begin{macrocode} + \global\let\this@page@closed\@empty +% \end{macrocode} +% +% \begin{macrocode} + \let\@elt\initialise@float@class + \float@classes@list + \let\@elt\relax +% +%\showfloatlists +%\show\area@ddd\show\@activelist +% for safety + \global\let\this@float@box\@undefined +%<*trace> + \@tracepop{initialise@next@page} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% + +% +% \endinput +\endinput +% +% $Log: xo-new.dtx,v $ +% Revision 1.25 2000/08/11 07:14:23 latex3 +% added header +% +% Revision 1.24 2000/08/11 06:49:09 latex3 +% untabify +% +% Revision 1.23 2000/08/05 10:01:26 latex3 +% ensure that \make@area@floats@box doesn't do any harm to areas not set +% up via \DeclareFloatArea +% +% Revision 1.22 2000/08/04 15:50:31 latex3 +% \flushbottom default again +% +% Revision 1.21 2000/08/04 13:58:58 latex3 +% \bot@areas need to be ordered by column at the moment!!!! +% +% Revision 1.20 2000/08/04 10:20:09 latex3 +% removed old experimental code for grid layout +% +% Revision 1.19 2000/07/22 06:30:50 latex3 +% fixed bug in positioning bottom floats +% +% Revision 1.18 2000/07/19 17:12:53 latex3 +% introduced float sequence list +% +% Revision 1.17 2000/07/10 19:22:12 latex3 +% more grid support +% +% Revision 1.16 2000/07/04 19:48:55 latex3 +% experimental stuff for GRIDs +% start writing out columnsizes (unused) +% use \update@this@area@columns +% +% Revision 1.15 2000/06/29 17:16:59 latex3 +% introduced \setup@this@area +% +% Revision 1.14 2000/06/26 15:17:26 latex3 +% prototype support for \pagesetup@float@area@sep +% +% Revision 1.13 2000/06/16 11:21:07 latex3 +% rename \construct@and@test@col@height to \construct@and@test@col@ht +% rename \construct@and@test@col@heights to \construct@and@test@col@hts +% rename \cl@height1 to \@col@ht@1 (etc) +% +% Revision 1.12 2000/06/15 15:22:36 latex3 +% implemented new semantics for area names +% +% Revision 1.11 2000/06/13 21:23:03 latex3 +% *** empty log message *** +% +% Revision 1.10 2000/05/04 09:21:27 latex3 +% urg: \this@area undefined inside the output routine, so captions got +% typeset with whatever was the last \this@area. +% +% Revision 1.9 2000/05/03 18:41:52 latex3 +% still overwriting code for xo-final 1.15 ! (not 1.16) +% enabling support for caption templates +% +% Revision 1.8 2000/04/21 19:16:32 latex3 +% activate my version of xo-final +% +% Revision 1.7 2000/04/21 19:05:21 latex3 +% my version of xo-final mainly +% +% Revision 1.6 2000/04/09 20:02:42 latex3 +% first draft of marginpar support +% +% Revision 1.5 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.4 2000/02/26 18:26:08 david +% code moved to xo-* +% +% Revision 1.3 2000/02/13 21:37:20 latex3 +% ooops, my ultrix rcs is too old to guess the comment char correctly +% so we better add explicit \endinput +% +% Revision 1.2 2000/02/13 21:35:25 latex3 +% wording +% +% Revision 1.1 2000/02/13 21:34:51 latex3 +% Initial revision +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-or.dtx b/Master/texmf-dist/source/latex3/xor/xo-or.dtx new file mode 100644 index 00000000000..6aef48254b1 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-or.dtx @@ -0,0 +1,5188 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-or.dtx,v 1.53 2000/08/11 07:14:25 latex3 Exp $ +% \end{macrocode} +% +% \subsection{A flowchart of the algorithm} +% +% Several output routines are employed. Output routines (that is, +% macros to be used as the sole content of the primitive |\output| +% register) are named xxx@or. Typically a companion macro named +% setup@xxx is called to initialise the state (typically setting +% vsize) and to assign |\output|. +% +% +% [The flow chart has be cut into pieces and individual pieces are +% shown below.] +% +% ^^A \input{xo-flow-chart.sty} ^^A .sty to ease updating +% +% +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% +% +% \subsection{General helper Routines} +% +% \begin{macro}{\@gobblethree} +% Get rid of three tokens or brace groups. +% \begin{macrocode} +\long\def\@gobblethree#1#2#3{} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\xin@} +% Like |\in@| but with both args (which have to be single tokens!) +% expanded. Should be replaced by a proper interface. +% \begin{macrocode} +\def\xin@#1#2{% +% expanded once: + \expandafter\def\expandafter\in@@\expandafter##\expandafter1#1##2##3\in@@{% + \ifx\in@##2\in@false\else\in@true\fi}% + \expandafter\expandafter\expandafter\in@@\expandafter#2#1\in@\in@@} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\gincrement@num} +% Globally increment a ``number macro'' by one. +% \begin{macrocode} +\def\gincrement@num#1 { +% \end{macrocode} +% We don't want to modify |\count@| here as it might hold some +% important data so we do everything in a group. +% \begin{macrocode} + \begingroup + \count@#1 + \advance\count@\@ne + \xdef#1{\the\count@} + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\gdecrement@num} +% Globally decrement a ``number macro'' by one. +% \begin{macrocode} +\def\gdecrement@num#1 { + \begingroup + \count@#1 + \advance\count@\m@ne + \xdef#1{\the\count@} + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\split@skip} +% \begin{macro}{\check@for@fil} +% \begin{macro}{\get@plus@part} +% \begin{macro}{\get@minus@part} +% |\split@skip| takes four aguments: a template key name (for error +% recovery), a skip specification (e.g., either the value of a skip +% register via |\the|\meta{register}, or a macro holding the +% information, or the specification directly), and two dimen +% registers. The skip specification is taken apart and the first +% dimen register receives ``plus'' part and the second the +% ``minus'' part. If the specification contains any |fil| parts an +% error is generated since these values can't be assigned to a +% dimen register. +% \begin{macrocode} +\begingroup +% \end{macrocode} +% We employ the |\lowercase| trick to get certain letters with +% |\catcode| 12 since we have to scan for them (they are what +% |\the| outputs. So if we say |MINUS| below we get |minus| but all +% |\catcode|d 12. +% \begin{macrocode} +\catcode`\M=12 +\catcode`\I=12 +\catcode`\N=12 +\catcode`\U=12 +\catcode`\S=12 +% \end{macrocode} +% We need |p| with |\catcode| 12 to scan for |pt| but we also need +% |P| with |\catcode| 11 to be able to say |\PackageError|. So we +% claim lowecase of |Z| is |p| and then say |ZT| and |ZLUS| below. +% \begin{macrocode} +\catcode`\Z=12 +\lccode`\Z=`\p +\catcode`\T=12 +% \end{macrocode} +% And we need to scan for |FIL|: +% \begin{macrocode} +\catcode`\L=12 +\catcode`\F=12 +% \end{macrocode} +% And the error message contains uppercase |V| and |O| and we want +% to retain those. +% \begin{macrocode} +\lccode`\V=`\V +\lccode`\O=`\O +% \end{macrocode} +% With the above prelims we now apply |\lowercase| to all the +% definitions below, which will put the correctly |\catcode|d +% strings in the parsing part of the macros. +% \begin{macrocode} +\lowercase{ +\gdef\split@skip #1#2#3#4{ +% \end{macrocode} +% |#2| is the skip specification. To be sure that the strings +% ``plus'', ``minus'', ``pt'' are always having |\catcode| 12 we +% assign it to a register first. Otherwise a user supplied string +% like |1in plus .5in| wouldn't be parsable since we are only +% looking for |pt| and also because in this case the |\catcode|s of +% |plus| would be 11. +% \begin{macrocode} + \@tempskipa#2\relax +% \end{macrocode} +% Then we pass this on to |\check@for@fil| which will make sure +% that there isn't any |fil| present and if not does the rest of +% the processing. +% \begin{macrocode} + \expandafter\check@for@fil \the\@tempskipa FIL\relax\check@for@fil + {\the\@tempskipa}{#3}{#4}{#1} + } +% \end{macrocode} +% +% \begin{macrocode} +\gdef\check@for@fil #1FIL#2\check@for@fil#3#4#5#6{ + \ifx\relax#2 + \expandafter + \get@minus@part #3MINUS 0ZT \get@minus@part{#4}{#5} + \else + #4\z@ + #5\z@ + \PackageError{template}{Value~ for~ key~ #6~ contains~ `fil(ll)'} + {Only~ finite~ minus~ or~ plus~ parts~ are~ allowed~ for~ this~ key.} + \fi + } +% \end{macrocode} +% +% \begin{macrocode} +\gdef\get@plus@part #1ZLUS#2ZT#3\get@plus@part#4{ + #4=#2pt\relax + } +% \end{macrocode} +% +% \begin{macrocode} +\gdef\get@minus@part #1MINUS#2ZT#3\get@minus@part#4#5{ + \get@plus@part #1ZLUS 0ZT\get@plus@part{#4} + #5=#2pt\relax + } +} +\endgroup +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% +% +% +% +% +% +% \subsection{Special Output Routine Penalties} +% +% +% \begin{macro}{\output@collect@penalty} +% Special penalty marking the point at which the collection OR ended. +% \begin{macrocode} +\mathchardef\output@collect@penalty=20202 +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\output@balance@penalty} +% Special penalty marking the point at which the collection OR +% should end collection because we want to balance the material. +% \begin{macrocode} +\mathchardef\output@balance@penalty=10010 +% \end{macrocode} +% \end{macro} +% +% +% Other special penalties are inbetween -10000 and -10010. Those will +% not stop the collection OR but are instead recorded along the way. +% +% \begin{macro}{\output@columnbreak@penalty} +% Special penalty marking the point a forced column break was +% requested by the user. +% \begin{macrocode} +\mathchardef\output@columnbreak@penalty=10005 +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\output@flush@float@penalty} +% Special penalty to trigger float flushing for one or more types. +% \begin{macrocode} +\mathchardef\output@flush@float@penalty=10006 +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\output@here@float@penalty} +% Special penalty for floats that should stay with their callout. +% \begin{macrocode} +\mathchardef\output@here@float@penalty=10007 +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\output@grid@align@penalty} +% Special penalty for places that should fall on the page grid. +% \begin{macrocode} +\mathchardef\output@grid@align@penalty=10008 +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \subsubsection{Utilities for Special Output Routine Penalties} +% +% +% \begin{macro}{\add@badly@guarded@penalty} +% Put a special penalty into the output and guard it with a +% box. The reason this macro is called |\add@badly@guarded@penalty| +% is that such a box of size zero is still messing up spacing +% caluclations. Why? Because when the penalty is reached on the MVL +% the preceeding line has already be fully added (i.e., including +% its depth). This means that \TeX{} might not reach it at all in +% time! For example, if the preceeding line would be the last line +% of the page the depth would not be taken into account yet, but by +% the time we reach the special penalty it has been added to +% |\pagetotal| and that may result in not fitting anymore onto the +% page. +% +% A solution would be to use a box that has the same depth as its +% preceeding box and a negative height so that it effectively +% doesn't modify the galley length. Easy, right? The only problem +% is that in case of |\vadjust| (and that is unfortunately the more +% important case) we just don't know what the preceeding depth is, +% since |\prevdepth| will always give us a friendly |-1000pt| in +% that case (start of a vertical sub-list\ldots). +% +% So not so easy after all. The way out of this dilemma turned out +% to be complicated and involves a lot of strange corrective +% actions in the collection process, see there for a replacement of +% that box and what else can go wrong if one delves into messing +% around with that part of \TeX. +% \begin{macrocode} +\def\add@badly@guarded@penalty#1 { + \ifvmode + \nointerlineskip + \vbox to\z@{\vss\the#1}\penalty-#1\relax + \else + \@bsphack + \vadjust{\vbox to\z@{\vss\the#1}\penalty-#1\relax} + \@esphack + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\add@guarded@penalty} +% Put a special penalty into the output. To ensure that it doesn't +% get mistakenly removed during breaking preceed it with a ``guard +% box'' which is later removed again. --- Actually no longer used +% but replacement isn't yet finalised.\footnote{CLEANUP!} +% \begin{macrocode} +\def\add@guarded@penalty#1 + {\guard@box{BUG:~\string#1}\penalty-#1\relax} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\guard@box} +% Could be moved into the previous macro. +% +% The way it is written (using |\prevdepth|) this can only be used +% in vertical mode! We have to carry over the |\prevdepth| and +% append the box without adding any additional interline +% space. Without it one gets nasty extra glue blobs of height +% |\baselineskip| somewhere in the output. +% \begin{macrocode} +\def\guard@box#1{ + \dimen@\prevdepth + \nointerlineskip + \vbox to0pt{\vss \rlap{#1}\kern\z@} + \prevdepth\dimen@ +} +% \end{macrocode} +% Better implementation? The above is wrong!\footnote{FIX!} +% \begin{macrocode} +\def\guard@box#1{ + \dimen@\prevdepth + \nointerlineskip + \begingroup + \setbox\z@\vbox to\z@{\vss \rlap{#1}} + \dp\z@\dimen@ + \box\z@ + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\remove@guard@box@from@cclv} +% Remove a guard box again. This always happens in the OR and so we +% hard code the box number for speed. +% +% Chris thinks this needs a maxdepth setting. +% \begin{macrocode} +\def\remove@guard@box@from@cclv{ + \global\setbox\@cclv \vbox{\boxmaxdepth\@maxdepth \unvbox\@cclv + \global\setbox\removed@guard@box\lastbox} +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\readd@guarded@penalty} +% Readding a guared penalty including the box that was removed +% earlier. Probably not needed in the end either since the way it +% is used at the moment we have a |\topskip| problem this +% way.\footnote{FIX!!!!} +% \begin{macrocode} +\def\readd@guarded@penalty#1 { + \box\removed@guard@box +%FMi what about topskip? + \penalty-#1\relax} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\removed@guard@box} +% \begin{macrocode} +\newbox\removed@guard@box +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \subsection{Columns and their Data Structures} +% +% \begin{macro}{\col@count} +% We are collecting stuff for a given number of columns. This +% number of column is available in a count register. +% \begin{macrocode} +\let\col@count \col@number % reuse a register from LaTeX + % which is named differently there +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\curr@col@count} +% Register denoting the column number of the current column while +% we cut the galley etc. Should always be modified globally since +% it is used within output routines. +% \begin{macrocode} +\newcount\curr@col@count +% \end{macrocode} +% \end{macro} +% +% +% +% \DescribeMacro\col@box@FOO +% Per column number FOO we have one box register allocated in which +% the column text from the galley is stored during trials and page +% makeup. +% +% \DescribeMacro\col@ht@FOO +% Per column number FOO we have dimen register allocated which +% holds the vertical target size for the column during the trials. +% +% \DescribeMacro\col@t@floats@FOO@number +% Per column number FOO we have a macro number in which we count +% the number of top floats we have seen so far in this column. This +% is used to implement |\pagesetup@float@area@sep| handling. +% +% \DescribeMacro\col@b@floats@FOO@number +% Per column number FOO we have a macro number in which we count +% the number of bottom floats we have seen so far in this column. This +% is used to implement |\pagesetup@float@area@sep| handling. +% +% +% \DescribeMacro\col@t@delta@FOO +% Per column number foo we have a macro in which we record the +% difference between the real size of all top floats (including +% there separation spaces) and the nominal size which is used to +% determine the vertical size of the remaining text column. The two +% may differ if we do grid typesetting. +% +% \DescribeMacro\col@b@delta@FOO +% Same kind of delta is recorded per column for the bottom floats. +% +% \DescribeMacro\fl@FOO@BAR +% For each float type BAR (e.g., |figure|, |table|, etc.) and each +% column number FOO we have a macro which holds the highest float +% sequence number for floats of type BAR allocated to column FOO or +% zero if no float has been allocated so far. +% +% \DescribeMacro{\fl@0@BAR} +% For each float type BAR (e.g., |figure|, |table|, etc.) +% |\fl@0@BAR| holds the highest sequence number in columns of the +% previous page. +% +% \DescribeMacro\tfl@FOO@BAR +% |\tfl@FOO@BAR| is like |\fl@FOO@BAR| but only stores information +% about floats allocated to top areas. +% +% + +% \begin{macro}{\col@box@1} +% \begin{macro}{\col@box@2} +% \begin{macro}{\col@box@3} +% \begin{macro}{\col@box@4} +% \begin{macro}{\col@box@5} +% \begin{macro}{\col@box@6} +% Need a box per column (currently fixed at six) to hold material +% from the galley for this column. +% \begin{macrocode} +\expandafter\newbox\csname col@box@1\endcsname +\expandafter\newbox\csname col@box@2\endcsname +\expandafter\newbox\csname col@box@3\endcsname +\expandafter\newbox\csname col@box@4\endcsname +\expandafter\newbox\csname col@box@5\endcsname +\expandafter\newbox\csname col@box@6\endcsname +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\col@ht@ 1} +% \begin{macro}{\col@ht@ 2} +% \begin{macro}{\col@ht@ 3} +% \begin{macro}{\col@ht@ 4} +% \begin{macro}{\col@ht@ 5} +% \begin{macro}{\col@ht@ 6} +% Need a dimen\footnote{Could be a macro if we find ourselves to +% use up too many dimens.} per column to hold its current vertical +% target size. +% \begin{macrocode} +\expandafter\newdimen\csname col@ht@ 1\endcsname +\expandafter\newdimen\csname col@ht@ 2\endcsname +\expandafter\newdimen\csname col@ht@ 3\endcsname +\expandafter\newdimen\csname col@ht@ 4\endcsname +\expandafter\newdimen\csname col@ht@ 5\endcsname +\expandafter\newdimen\csname col@ht@ 6\endcsname +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% +% +% +% \subsubsection{Utilities for Columns and their Data Structures} +% +% \begin{macro}{\forall@columns} +% If we want to do something to data structures for all column we +% can use the macro |\forall@columns|. Within its argument the +% current column is available in the register +% |\curr@col@count|. The macro takes some pains to restore the +% original value of |\curr@col@count| afterwards. +% \begin{macrocode} +\def\forall@columns#1{ + \edef\saved@curr@col@count{\the\curr@col@count} + \global\curr@col@count\z@ + \@whilenum \curr@col@count<\col@count \do + {\global\advance\curr@col@count\@ne + #1 + } + \global\curr@col@count\saved@curr@col@count\relax +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\initialise@column@data} +% \begin{macrocode} +\def\initialise@column@data{ +%<*trace> + \@tracepush{initialise@column@data} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \global\let\best@trial\@empty + + \forall@columns + { + + \global\csname col@ht@ \the\curr@col@count\endcsname\textheight + +% \end{macrocode} +% +% \begin{macrocode} + \expandafter + \g@addto@macro\expandafter\best@trial\expandafter + { + \expandafter + \global + \csname col@ht@ \the\curr@col@count\endcsname + \textheight + } +% \end{macrocode} +% We haven't seen any top or bottom floats yet. +% \begin{macrocode} + \global\@namedef{col@t@floats@ \the\curr@col@count + @number}{0} + \global\@namedef{col@b@floats@ \the\curr@col@count + @number}{0} +% \end{macrocode} +% For the same reason the delta values for top and bottom areas are +% zeroed.\footnote{Using \texttt{\string\let} and +% \texttt{\string\z@} in places like this would be more faster and +% shorter, but it wouldn't work nicely in tracing as it would make +% unexpandable macros. Perhaps the tracing versions should be made +% specially.} +% \begin{macrocode} + \global\@namedef{col@t@delta@ \the\curr@col@count}{0pt} + \global\@namedef{col@b@delta@ \the\curr@col@count}{0pt} + } + +%<*trace> + \tr@ce{\meaning\best@trial} + \@tracepop{initialise@column@data} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \subsubsection{User Commands for Columns} +% +% +% \begin{macro}{\columnbreak} +% And here is the user command formaking a column +% break:\footnote{All this is stolen from \texttt{multicol.sty} and +% there is still code that doesn't belong here.} |\columnbreak| is +% modelled after |\pagebreak| except that we generate a penalty +% |-\output@columnbreak@penalty|. +% \begin{macrocode} +\def\columnbreak{ +% \end{macrocode} +% We have to ensure that it is only used within a multicolumn +% environment since if that penalty would be seen by the unmodified +% \LaTeX{} output routine strange things would happen. +% \begin{macrocode} + \ifnum\col@count<\tw@ + \PackageError{xoutput} + {\noexpand\columnbreak~ in~ one-column~ mode} + {???} + \else + \ifvmode + \penalty -\output@columnbreak@penalty + \else + \@bsphack + \vadjust{\penalty -\output@columnbreak@penalty} + \@esphack + \fi + \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% +% +% +% +% \subsection{Float Areas and their Data Structures} +% +% Naming conventions for float areas is as follows: +% \begin{quote} +% \meta{identifier}\meta{start-column}\meta{span-count}. +% \end{quote} +% The \meta{identifier} is a single letter denoting the type of area, +% e.g., |t| for top, |b| for bottom. The \meta{span-count} is a single +% digit denoting the number of columns to span. The +% \meta{start-column} is a single digit\footnote{with a bit of care in +% the code this could be extended to allow more than one digit.} +% denoting the start column of the area. Thus |t32| is a top area +% starting at column three and spanning two columns ie three and four. +% A restriction due to the naming scheme is that currently no more than +% 9 columns are possible. +% +% Only a subset of the float areas is allowed to be popolated on a +% page. In essense the current algorithm does not support placements +% that result in splitting the text of a column due to a float (other +% than column `here' floats).\footnote{Perhaps this restriction is +% lifted one day.} This means that if $pcs$ ($p=\textrm{pos}$, +% $c=\textrm{column}$, $s=\textrm{span}$) is a float area that is +% being populated then it must prevent populating all float areas that +% satisfy either +% \[ +% pij \textrm{ with } i < c \leq i+j < c+s +% \] +% or +% \[ +% pij \textrm{ with } i \leq c+s < i+j \leq \verb=\col@count= +% \] +% The first formula describes the areas which partly overlap from the +% left, the second formula describes those that partly overlap from +% the right. Areas which are sub- or super-areas, e.g., \texttt{t13} +% and \texttt{t22} do not affect each other. The above restriction is +% necessary to prevent situations like +%\begin{verbatim} +%aaaaaaaaaaa 444 +%aaaaaaaaaaa 444 +%aaaaaaaaaaa 444 +%111 222 bbbbbbb +%111 222 bbbbbbb +%111 222 bbbbbbb +%111 222 333 444 +%111 222 333 444 +%\end{verbatim} +% +% +% For each area |FOO| (e.g., |t13|) we keep a number of global +% variables to store relevant data. These are the following +% variables\footnote{Not a consistent lot}: +% +% \DescribeMacro\area@FOO +% Floats allocated to the area |FOO| by the page building process +% are stored as an |\@elt| list in the macro |\area@FOO|. +% +% \DescribeMacro\pagesetup@FOO@float@num +% The maximum number of floats allowed in area |FOO| is stored in +% the macro |\pagesetup@FOO@float@num|. +% +% \DescribeMacro\FOO@@float@count +% +% The number of floats currently allocated to area |FOO| is stored +% in the count register |\FOO@@float@count|.\footnote{This is a +% waste of registers!} +% +% \DescribeMacro\pagesetup@FOO@class@close +% The areas that should be closed for floats of the same sequence class the +% moment a float is placed into area |FOO|. This is a comma +% separated list. +% +% \DescribeMacro\pagesetup@FOO@all@close +% The areas that should be closed for all float sequence classes the +% moment a float is placed into area |FOO|. This is a comma +% separated list. +% +% +% +% \begin{macro}{\known@areas} +% |\known@areas| are the areas known to the system.\footnote{or +% something else, the semantics are still changing} Initialisation +% is done when declaring individual areas. +% \begin{macrocode} +\def\known@areas{} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\used@areas} +% |\used@areas| are the areas used by the current page setup. +% Initialisation is done in the page setup template so the +% definition below is arbitrary. +% \begin{macrocode} +\def\used@areas{ t11 b11 } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\@activelist} +% \begin{macrocode} +\let\@activelist\@empty +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@mvllist} +% \begin{macrocode} +\let\@mvllist\@empty +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\area@ddd} +% The list of deferred floats (which we consider being an area in +% some respects). +% \begin{macrocode} +\let\area@ddd\@empty +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\pagesetup@ddd@class@close} +% \begin{macro}{\pagesetup@ddd@all@close} +% \begin{macrocode} +\def\pagesetup@ddd@class@close{\pagesetup@area@list} +\let\pagesetup@ddd@all@close\@empty +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\this@open@areas} +% \begin{macro}{\saved@this@open@areas} +% In |\this@open@areas| we store the float areas which we will try +% to place a float onto the current page. These areas are tried one +% after another until the float is successfully placed or we run +% out of areas. The list does not have any separator (as we assume +% that all areas are denoted by a letter followed by two digits). +% +% |\saved@this@open@areas| is the seved version needed for +% backtracking if we encounter a flush point that can't be resolved. +% \begin{macrocode} +\let\this@open@areas\@empty +\let\saved@this@open@areas\@empty +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\this@closed@areas} +% In |\this@closed@areas| we store the float areas which have been +% closed for the current float while trying to place it. In this +% list each area name is followed by a comma (to avoid spurious +% matches). It is initialised with |closed@\this@class @areas| when +% we fetch a new float to try. Once the float is placed we write +% the then current value back. +% \begin{macrocode} +\let\this@closed@areas\@empty +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\this@page@closed} +% In |\this@page@closed| we store the float areas which have been +% closed for all float types. In this list each area name is +% followed by a comma (to avoid spurious matches). +% \begin{macrocode} +\let\this@page@closed\@empty +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\t11@float@count} +% \begin{macro}{\t21@float@count} +% \begin{macro}{\b11@float@count} +% \begin{macro}{\b21@float@count} +% The float counts are allocated dynamically when an area is +% declared if they are not defined, but we have a few registers +% left over from \LaTeX{}'s old OR so we might as well use them. +% \begin{macrocode} +%\expandafter\newcount\csname t11@float@count\endcsname +\expandafter\let\csname t11@float@count\endcsname \@topnum +%\expandafter\newcount\csname b11@float@count\endcsname +\expandafter\let\csname b11@float@count\endcsname \@botnum +%\expandafter\newcount\csname t12@float@count\endcsname +\expandafter\let\csname t12@float@count\endcsname \@dbltopnum +%\expandafter\newcount\csname b12@float@count\endcsname +\expandafter\let\csname b12@float@count\endcsname \@dblbotnum +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\ddd@float@count} +% And we need to declare the one for the defer area is that isn't +% going through the normal initialisation process. +% \begin{macrocode} +\newcount\ddd@float@count +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\pagesetup@float@area@sep} +% |\pagesetup@float@area@sep| is the separation to use between two +% adjacent float areas. +% \begin{macrocode} +\newskip\pagesetup@float@area@sep +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\pagesetup@float@text@sep} +% |\pagesetup@float@text@sep| is the separation to use between +% column text and adjacent float areas. +% \begin{macrocode} +%\newskip\pagesetup@float@text@sep +\let\pagesetup@float@text@sep\textfloatsep % reuse register +\let\textfloatsep\@undefined +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\pagesetup@float@float@sep} +% |\pagesetup@float@float@sep| is the separation to use between +% two floats in the same float area. +% \begin{macrocode} +%\newskip\pagesetup@float@float@sep +\let\pagesetup@float@float@sep\floatsep % reuse register +\let\floatsep\@undefined +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\pagesetup@float@text@shrink} +% |\pagesetup@float@text@shrink| is the allowed shrinkability of +% |\pagesetup@float@text@sep|. This is used if we are doing grid +% typesetting and have to adjust the vertical size of the column. +% \begin{macrocode} +\newdimen\pagesetup@float@text@shrink +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\pagesetup@float@inline@sep} +% |\pagesetup@float@inline@sep| is the separation to use between +% two floats in the same float area. +% \begin{macrocode} +%\newskip\pagesetup@inline@float@sep +\let\pagesetup@float@inline@sep\intextsep % reuse register +\let\intextsep\@undefined +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\pagesetup@float@inline@shrink} +% |\pagesetup@float@inline@shrink| is the allowed shrinkability of +% |\pagesetup@float@inline@sep|. This is used if we are doing grid +% typesetting and have to adjust the vertical size of object to be +% added, e.g., an inline float with its caption. +% \begin{macrocode} +\newdimen\pagesetup@float@inline@shrink +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \subsubsection{Utilities for Float Areas and their Data Structures} +% +% +% \begin{macro}{\initialise@areas} +% Initialise all float areas used within the current page setup. +% \begin{macrocode} +\def\initialise@areas{ + \expandafter\initialise@areas@loop + \used@areas + \relax\relax\relax +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\initialise@areas@loop} +% The |\initialise@areas@loop| picks up the next three tokens and +% interprets them as the component of an area name. +% \begin{macrocode} +\def\initialise@areas@loop#1#2#3{ + \ifx#1\relax + \else + \global\csname #1#2#3@float@count\endcsname\z@ + \global\expandafter\let\csname area@#1#2#3\endcsname\@empty + \expandafter\initialise@areas@loop + \fi} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\first@of@type} +% The macro |\first@of@type| takes a \meta{type} name as its first +% argument and an \meta{area} area name as its second argument and +% will return in the macro |\returned@sequence@number| the sequence +% number of the first float of type \meta{type} currently in +% \meta{area}. If there is no float of type \meta{type} in this +% area it will return |-1| (impossible sequence number). +% \begin{macrocode} +\def\first@of@type#1#2{ + \begingroup + \def\@tempb{#1} + \gdef\returned@sequence@number{-1} + \def\@elt{\expandafter\first@of@type@aux\the\toks} + \csname area@#2\endcsname + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\first@of@type@aux} +% This macro picks up the type definition in the data structure of +% a float and compares it with the name started in |\@tempb|. If +% they agree |\returned@sequence@number| will get updated to +% contain the sequence number of the float. +% \begin{macrocode} +\def\first@of@type@aux#1#2#3#4#5#6#7{ + \def\@tempa{#6} + \ifx\@tempa\@tempb + \gdef\returned@sequence@number{#7} + \let\@elt\@gobble + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\last@of@type} +% The macro |\last@of@type| takes a \meta{type} name as its firat +% argument and an \meta{area} area name as its second argument and +% will return in the macro |\returned@sequence@number| the sequence +% number of the last float of type \meta{type} currently in +% \meta{area}. If there is no float of type \meta{type} in this +% area it will return |-1| (impossible sequence number). +% \begin{macrocode} +\def\last@of@type#1#2{ + \begingroup + \def\@tempb{#1} + \gdef\returned@sequence@number{-1} + \def\@elt{\expandafter\last@of@type@aux\the\toks} + \csname area@#2\endcsname + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\last@of@type@aux} +% \begin{macrocode} +\def\last@of@type@aux#1#2#3#4#5#6#7{ + \def\@tempa{#6} + \ifx\@tempa\@tempb + \gdef\returned@sequence@number{#7} + \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\setup@this@area} +% +% Whenever the algorithm works with some area as the current +% candidate for putting a float into it uses the following commands +% to reference this area: +% +% \DescribeMacro\this@area +% The macro |\this@area| holds the name of the candidate area, e.g., +% it would expand to something like |t13|. +% +% \DescribeMacro\this@area@type +% The macro |\this@area@type| holds the ``type'' of the area, e.g., |t| +% in the above example. +% +% \DescribeMacro\this@area@col@number +% The macro |\this@area@col@number| holds the starting column of the +% area, e.g., |1| in the above example. +% +% +% \DescribeMacro\this@area@span@number +% The macro |\this@area@span@number| holds the number of columns +% spanned by the area, e.g., |3| in the above example. +% +% All the above macros are globally assigned when calling +% |\setup@this@area|. The argument is fully expanded (!) since one +% typical usage to pick up the first area from an area like +% |\this@open@areas| which can then be done within the argument. +% +% \begin{macrocode} +\def\setup@this@area #1 { + \xdef\this@area{#1} +% \end{macrocode} +% This really relies on |\this@area| containing exactly three +% tokens (no error recovery if not). +% \begin{macrocode} + \expandafter\gassign@area@type@col@and@span@aux\this@area +} +\def\gassign@area@type@col@and@span@aux #1#2#3{ + \gdef \this@area@type {#1} % type + \gdef \this@area@col@number {#2} % col + \gdef \this@area@span@number {#3} % span +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\update@this@area@columns} +% +% If we have to do updates for all columns that are spanned by the +% current target area we can call |\update@this@area@columns|. It +% loops through the columns with |\count@| referring to the current +% column. Data structure updates have to be global as everything +% happens within a group. +% \begin{macrocode} +\def\update@this@area@columns #1 { + \begingroup + \count@\this@area@col@number\relax + \advance\count@\this@area@span@number\relax + \loop + \ifnum \this@area@col@number < \count@ + \advance\count@\m@ne +%<*trace> + \tr@ce{looking~ at~ column:~ \the\count@} +%</trace> + #1 + \repeat + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \newpage +% \subsection{Collection Output Routine} +% +% \begin{description} +% \item[Entry:] |\setup@collection@or| +% \item[Exit:] |\setup@float@placement| +% \item[Prereq:] |\initialise@next@page| should have been called before. +% \item[Description:] Grab enough text (and float call-outs) to obtain +% a galley big enough to form the next text page. The page goal is +% set to a value high enough to ensure that in normal cases text +% for all columns of the page is collected, i.e, we have a safety +% margin of 5 extra lines per column.\footnote{This should be made +% customisable for unusual jobs!} +% +% If the output routine is triggered with a special penalty (in the +% range of $-10000>p>-10010=|\output@balance@penalty|$) the penalty +% is moved into the collection box |\partial@galley@box| without +% further processing; otherwise the collection is ended and all +% collected material is moved to |\@holdpg| for use in page +% production. +% +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \setup@collection@or +% | +% V +% New OR: \collection@or +% | +% |<----------------------------------------- +% | | +% (natural end of collection reached?) | +% | | | +% yes no | +% | | | +% | (record special penalty and carry on)---- +% | +% V +% \setup@float@placement +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% Chris noted that |\@holdpg| never gets emptied. This could be +% done when the Collection OR is started for a new page (in this +% next macro).\footnote{FIX} +% +% \begin{macro}{\setup@collection@or} +% \begin{macrocode} +\def\setup@collection@or{ +%<*trace> + \@tracepush{setup@collection@or} +%</trace> + \global\holdinginserts\@ne +% \end{macrocode} +% We set the |\vsize| for collection to the height of a single +% column (plus a safety margin of currently five lines to allow for +% vanishing space at margins) multiplied by the number of columns. +% \begin{macrocode} + \global\vsize\textheight + \global\advance\vsize 5\baselineskip + \global\multiply\vsize \col@count +%<*trace> + \tr@ce{collection~vsize:~\the\vsize } +%</trace> +% \end{macrocode} +% Initialising the flush point handling: +% \begin{macrocode} + \@flushseenfalse + \@flushfailfalse +% \end{macrocode} +% We may have to restart the collection (whenever we find a here or +% a flush point) and we don't want to get extra space added via +% |\topskip|. So we can either make |\topskip| zero during +% collection (current strategy) or back it out whenever we restart. +% +% We can't set topskip to zero now since a) we want a proper +% |\topskip| for the first column and b) due to a bloody fix for the +% old \LaTeX{} OR, a value of |0pt| is set to |1sp| in +% |\begin{document}| and this results in adding |1sp| at every +% special point\ldots no, we definitely do not want this! It took +% me ages to find out why the grid design macros didn't work. +% \begin{macrocode} + \xdef\saved@topskip{\the\topskip} +% \end{macrocode} +% +% \begin{macrocode} + \global\output{\collection@or} +%<*trace> + \@tracepop{setup@collection@or} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\if@collecting@new@material} +% There are actually two collecting modes: one when the recent +% contributions are empty and we are really collecting material +% that we haven't seen before and one where we collect material +% that has been collected on a previous collection pass and has been +% placed again on to the main vertical list. The reason why we need +% to differentiate between the two is that in the second case we +% have to handle the special penalties differently since by now +% they are already surrounded by the proper guard boxes before and +% after and we better do not disturb this fragile setup. +% \begin{macrocode} +\newif\if@collecting@new@material +\def\@collecting@new@materialfalse + {\global\let\if@collecting@new@material\iffalse} +\def\@collecting@new@materialtrue + {\global\let\if@collecting@new@material\iftrue} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\collection@or} +% The output routine during the collection phase assembles the +% material until enough has been gathered to be sure to fill a +% page. +% \begin{macrocode} +\def\collection@or{ +%<*trace> + \@tracepush{collection@or} + \tr@ce{output~pen:~ \the\outputpenalty} +%{\x\showoutput\showbox255} +%</trace> +% \end{macrocode} +% We first look if the call to the OR is due to a special penalty. +% \begin{macrocode} + \@testfalse + \ifnum\outputpenalty < -\@M + \ifnum\outputpenalty > -\output@balance@penalty + \@testtrue + \fi + \fi + \if@test +%<*trace> + \tr@ce{Forced~ break~(\the\outputpenalty)~ seen\on@line} +%</trace> +% \end{macrocode} +% Whenever a special penalty, i.e., one between $-10000 > p > +% -10010$ is encountered we need some magic: +% \begin{itemize} +% \item We want to keep the the penalty in the collected material but +% nevertheless carry on with the collection. Simply moving the +% collected material to a separate box is not enough since then +% we will restart the collection with an empty page and thus +% receive a |\topskip| glue as well as probably losing material +% if there is anything discardable after the special penalty. +% \item But putting a zero box back and doing something to fix the +% problem with the |\topskip| glue isn't good either in case we +% later actually want to break after the line with special +% penalty, since then we would start a page with our inserted +% box, and in this case we would like to get a proper |\topskip| +% and we would like to get rid of discardable stuff. +% \item And there is another problem, we need a guard box in front of +% that special penalty, but this guard box should not be simply a +% |\null| box (as it is right now added by +% |\add@badly@guarded@penalty|) since that will result in wrong +% page calculations because it will make \TeX{} add the depth of +% the precious line to the page total which it shouldn't. +% \end{itemize} +% So what to do? First of all we remove the guard box in front of +% the special penalty (which is now at the end of box 255) since we +% want to replace that with something better, then we +% store away the depth of box 255 since we need that in a minute. +% \begin{macrocode} + \remove@guard@box@from@cclv +% \end{macrocode} +% We really have to say |\dp\@cclv| not |\pagedepth|. The latter is +% always zero in the OR which looks suspiciously like a bug or at +% least an inconsistency when Don implemented the change from \TeX2 +% to \TeX3 (in \TeX2 |\page...| registers were useless in the OR, +% now only |\pagedepth| seems to be left). +% \begin{macrocode} + \dimen@\dp\@cclv +% \end{macrocode} +% Then we subtract the size of the collected material from +% |\vsize| since we will store it away in a separate box for a +% while. Note that we have to use |\ht\@cclv| here not |\pagetotal| +% since the latter might be to large because of that |\null| +% box. The height of 255 on the other hand is, after the removal of +% that box the natural height of the material. +% \begin{macrocode} + \global\advance\vsize-\ht\@cclv +% \end{macrocode} +% Now we append the material to |\partial@galley@box|, this is +% straight forward. +% \begin{macrocode} + \global\setbox\partial@galley@box + \vbox{\ifvoid\partial@galley@box + \else + \unvbox\partial@galley@box + \fi + \unvbox\@cclv +% \end{macrocode} +% But how to add the penalty and how to guard it? We need a box or +% something to ensure the penalty doesn't get lost at a column +% break but we also want to avoid that \TeX{} adds the depth of the +% preceding line to |\pagetotal|. Fortunately we know this depth by +% now (we have just stored it in |\dimen@|), something we didn't +% know at the time the we added the penalty with +% |\add@badly@guarded@penalty|. So we could back up and then add a +% box with zero height and that depth. This way a break directly +% after this line would have the same |\pagetotal| as a break at +% the special penalty. In fact, instead of backing up using a +% |\kern| or a |\vskip| we can simply make the height of the box +% negative. The advantage is that this way we don't generate a +% break point between the box and a preceding box and thus don't +% have to use special precautions to prevent \TeX{} from breaking in +% front of the guard box.\footnote{This statement is only true for +% special penalties added using \texttt{\string\vadjust}, i.e., in +% hmode. If the penalty was added between paragraphs then there +% might be vertical space in front of the box. This might need +% special handling too. CHECK!} +% \begin{macrocode} + \setbox\z@\vbox to-\dimen@{} + \dp\z@\dimen@ + \box\z@ + \penalty\outputpenalty + } +%{\showoutput\batchmode\showbox\partial@galley@box\errorstopmode} +% \end{macrocode} +% So now we have put everthing we need into the +% |\partial@galley@box|, but how do we restart our collection +% process without running into the problems outlined above? +% +% Well, right now on the recent contributions there will be a +% penalty node (from our special penalty) which gets set to 10000 +% by \TeX{} followed perhaps by another penalty from the line +% breaking followed probably by interline glue calculated to make +% the next line of text fit vertically with the preceding one --- +% and we don't want to loose that that glue if we are ending up in +% the middle of a column. But we want to make it vanish if we +% happen to finally break at the special penalty place. +% +% So the trick is that we a) disable |\topskip| by setting it to +% |-\maxdimen| (not zero this might be too large still) and b) we +% add another of those funny boxes followed by a penalty of zero to +% allow for a break after it. +% +% If later on all this is put together again into a single box (in +% |\@holdpg|) we will have the following sequence there: +% \begin{itemize} +% \item text line (box) preceding the special penalty with depth $d$ +% or some other vertical material in which case $d=0\texttt{pt}$ +% \item special box with height $-d$ and depth $d$ +% \item special penalty, e.g. $-10008$ +% \item |\topskip| glue of 0pt +% \item special box with height $-d$ and depth $d$ +% \item |\penalty| 0 +% \item |\penalty| 10000 +% \item perhaps a |\penalty| and/or interline glue +% \item perhaps the next text line (box) +% \end{itemize} +% Now if during later processing we hit the special penalty +% |\pagetotal| has the same value as if we would have broken the +% galley directly after the text line, in other words we do not see +% the penalty too late (assume this happens to be the last line of +% the column then if |\pagetotal| would also have the extra depth +% added to it it might have been overfull and the penalty not being +% considered at all for this column). +% +% After the OR's have dealt with the special penalty, e.g., by +% flushing some floats, etc. the penalty will be replaced by 10000 +% and thus the next time the galley is processed there is no +% breakpoint between the two special boxes any more. As a result +% the next potential breakpoint is the penalty 0 which again +% results in exactly the same |\pagetotal| as before, i.e., if the +% text line was the last line to fit in the column then this +% breakpoint will still fit there. Thus if we break the column +% there then the interline glue etc will vanish and \TeX{} will +% insert |\topskip| glue (which has be set back to a normal value +% by then). If on the other hand, this break point is not chosen +% the interline glue will stay and thus the two text lines, before +% and after the special penalty will sit one |\baselineskip| apart +% just as they should. +% +% Woah. What did Don said on page 125 of \textit{The \TeX{}book}? +% (Deep breath.) You got that?\footnote{There are probably still +% cases that aren't covered I fear and the need for an explicit +% penalty 0 at the end is kind of toublesome, so we have to see if +% this needs further refinements.} +% +% And here is already the first case where the above method is not +% appropriate: if we stumble across a |\output@columnbreak@penalty| +% we need to discard any following glue, so we don't want a box +% intervene here.\footnote{Once this is interfaced with the galley +% code problems like this should vanish since then we can ensure +% that all such penalties are added to the galley on at save +% places. REDO THEN!} +% \begin{macrocode} + \global\topskip-\maxdimen % okay here? + \if@collecting@new@material + \ifnum \outputpenalty = -\output@columnbreak@penalty + \else + \setbox\z@\vbox to-\dimen@{} + \dp\z@\dimen@ + \box\z@ + \penalty\z@ + \fi + \fi +% \end{macrocode} +% +% \begin{macrocode} + \ifnum\outputpenalty=-\output@flush@float@penalty +%<*trace> + \tr@ce{Forced~ break~ =~ flush~ float~ point} +%</trace> + \@flushseentrue + \fi +% \end{macrocode} +% Otherwise either the we reached the natural end of the +% collection, or the point where we have been before (in case we +% are recollecting previously seen material) or we reached an +% |\output@balance@penalty|. +% \begin{macrocode} + \else + \ifnum\outputpenalty = -\output@collect@penalty +% \end{macrocode} +% If we got an |-\output@collect@penalty| then we are at the point +% to which the previous collection pass got. So, away with the +% guard box, then everything back onto the MVL and as a penalty we +% try to put what we have found in the previous collection pass. +% \begin{macrocode} + \remove@guard@box@from@cclv + \unvbox\@cclv +%<*trace> + \tr@ce{reinsert~penalty:~ \saved@outputpenalty\space + (unless~ 10000~ or~ <~ -9999)} +%</trace> + \ifnum\saved@outputpenalty > -\@M + \penalty + \ifnum\saved@outputpenalty=\@M + \z@ + \else + \saved@outputpenalty\relax + \fi +% \end{macrocode} +% We have a special situation to account for here: if we have a +% |\pagebreak| that ended the collection last time then it might +% still be the case that we haven't got to this point due to +% floats. So we would need to put that penalty back. But only then, +% and therese the catch! The alternative is to not stop a +% collection as such a point so that this problem doesn't arise in +% the first place. Right now we lose the +% penalty.\footnote{Unresolved situation. FIX!} +% \begin{macrocode} + \else + \fi +% \end{macrocode} +% Finally we change the |@collecting@new@material| switch since we +% are from now on looking at really new material. +% \begin{macrocode} + \@collecting@new@materialtrue + \else +% \end{macrocode} +% Next case is not functional right now\ldots +% \begin{macrocode} + \ifnum\outputpenalty = -\output@balance@penalty + \@balancetrue +%<*trace> + \tr@ce{BALANCE:~ break~ seen\on@line} +%</trace> + \xdef\saved@outputpenalty{0} +% \end{macrocode} +% This is now the point where the collection ended naturally: we +% save the penalty that triggered it and combine the +% |\partial@galley@box| if it contains material with the stuff now +% in 255 and put everything into |\@holdpg|. +% \begin{macrocode} + \else + \xdef\saved@outputpenalty{\the\outputpenalty} + \fi + \ifvoid\partial@galley@box + \global \setbox\@holdpg\box\@cclv + \else +%<*trace> + \tr@ce{Re-adding~ forced~ break(s)~ for~ splitting} +%</trace> + \global\setbox\@holdpg\vbox{ + \unvbox\partial@galley@box + \unvbox\@cclv} + \fi + +%\showbox\@holdpg + + \if@balance + \global\setbox\@holdpg\vbox{ + \unvbox\@holdpg + \penalty\outputpenalty % short for "-\output@balance@penalty" + } + \fi + + \mark@save@state + \mark@update@structure +% + \global\holdinginserts\z@ + + \global\topskip\saved@topskip + + \setup@float@placement + + \@collecting@new@materialfalse + \fi + \fi +%<*trace> + \@tracepop{collection@or} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\partial@galley@box} +% Need a box to store the partially collected galley. +% \begin{macrocode} +\newbox\partial@galley@box +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\initialise@float@class} +% +% \begin{macrocode} +\def\initialise@float@class#1{ +%<*trace> + \@tracepush{initialise@float@class} +%</trace> + \count@0\LastMark{#1} +% +% next line no longer used +% \global\expandafter\mathchardef\csname count@#1\endcsname\count@ +% +%<*trace> + \tr@ce{count~ (#1) = \the\count@} +%</trace> +% \end{macrocode} +% +% At some point the set of open areas at page start (for a +% given type of floats) should be specifiable through some +% templates. Using |\used@areas| is not really the right thing +% to do.\footnote{Code should vanish one day}. +% \begin{macrocode} + \global\expandafter\let\csname open@#1@areas\endcsname\used@areas + \global\expandafter\let\csname closed@#1@areas\endcsname\@empty +% \end{macrocode} +% +% \begin{macrocode} +%<*trace> + \tr@ce{open~ (#1) = \csname open@#1@areas\endcsname} + \tr@ce{closed~ (#1) = \csname closed@#1@areas\endcsname} +%</trace> +% \end{macrocode} +% +% |\fl@1@figure| are macros that expands to the highest numbered +% figure callout in this column (or zero if there is none). +% |\fl@0@figure| is the highest value from previous pages (or zero +% if there was never any float of this type). +% \begin{macrocode} + \forall@columns { + \ifnum \csname fl@ \the\curr@col@count @#1\endcsname>\z@ + \global\expandafter\let\csname fl@0@#1\expandafter\endcsname + \csname fl@ \the\curr@col@count @#1\endcsname + \expandafter\xdef + \csname fl@ \the\curr@col@count @#1\endcsname{0} + \fi +% \end{macrocode} +% |\tfl@1@figure| is like |\fl@1@figure| but only stores +% information about floats allocated to top areas. +% \begin{macrocode} + \expandafter\xdef + \csname tfl@ \the\curr@col@count @#1\endcsname{0} + } +%<*trace> + \@tracepop{initialise@float@class} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% +% \newpage +% +% \subsection{Placing Floats} +% +% +% \begin{description} +% \item[Entry:] |\setup@float@placement| +% \item[Exit:] |\setup@grab@column@or| or |\setup@best@column@or| +% \item[Prereq:] +% \item[Description:] +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \setup@float@placement +% | +% V +%(2)--> \float@placement@loop +% | +% <run with floats?> +% | | +% yes no----------> \setup@grab@column@or +% | +% V +% \trial@inner@loop +% | +% V +% <current float successfully placed in previous trial?> +% | | +% no yes +% | | +% (means we now try V +% again using different \try@next@float <------------------- +% placement rules below ) | | +% | | | +% | <\@activelist empty?> | +% | | | | +% | no yes | +% | | | | +% | | V | +% | (get it) \@activelist@empty@action | +% | | (= \setup@best@column@or) | +% -------------v---------------- | +% | | +% -----> \try@this@area (= \std@try@this@area, or | +% | | \relaxed@try@this@area) | +% | | | +% | <still open areas for current float type?> | +% | | | | +% | yes no---------------(defer float)-------------- +% | | | +% | (do some tests and perhaps | +% | close area this way) | +% | | | +% | <float allowed on this page/column (according to tests)?> | +% | | | | +% | yes no---------------(defer float)-------------- +% | | +% | <current area got closed by any test?> +% | | | +% | yes no +% | | | +% | (select next area) | +% | | | +% -------- V +% \pretests@success@action (\setup@grab@column@or) +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% +% +% +% +% \begin{macro}{\if@fail} +% \begin{macrocode} +\newif\if@fail +\def\@failfalse{\global\let\if@fail\iffalse} +\def\@failtrue{\global\let\if@fail\iftrue} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\setup@float@placement} +% +% \begin{macrocode} +\def\setup@float@placement { +% initialise before trial loop (needs work) +%<*trace> + \@tracepush{setup@float@placement} +%</trace> +% \end{macrocode} +% A bit statistics: how many floats do we have on the +% |\@activelist|? +% \begin{macrocode} +%<*progress> + \def\@elt{\global\advance\trial@count\@ne\@gobble} + \@activelist + \let\@elt\relax + \progress@separator + \progress@nl{STATS:~ floats~ waiting~ =~ \the\trial@count + \space on~ page~ \the\absolute@page@number} + \progress@separator + \global\trial@count\z@ +%</progress> +% \end{macrocode} +% We need the list of here floats during all trials. They are +% therefore saved in |\saved@herelist| at this point which is then +% used to initialise |\@herelist| at the beginning of each trial. +% \begin{macrocode} + \global\let\saved@herelist\@herelist +% \end{macrocode} +% +% \begin{macrocode} + \tighten@float@placement@conditions +% \end{macrocode} +% First time we run the |\float@placement@loop| we run it without +% actually trying any floats (i.e., we are just cutting the +% galley).\footnote{Could be improved: if there are no floats then +% we run it once too often this way (per page) so\ldots} +% \begin{macrocode} + \run@with@floatsfalse + \float@placement@loop +%<*trace> + \@tracepop{setup@float@placement} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\float@placement@loop} +% Place the galley box back on the MVL. Needs to be done via the +% special output routine call |\mark@restore@state| to ensure that +% \TeX's primitive marks reflect the `logical' previous page rather +% than the previous actual output routine call. +% \begin{macrocode} +\def\float@placement@loop{ +%<*trace> + \@tracepush{float@placement@loop} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \deadcycles\z@ + \global\let\@activelist@empty@action\setup@best@column@or + \global\let\pretests@success@action\setup@grab@column@or +% \end{macrocode} +% +% If we are doing trials we have to place a special penalty at the +% end of the MVL but if we are cutting up the galley for +% typesetting we don't want this penalty. Since at this point it is +% not clear in which case we are we defer this action until +% later.\footnote{This part of the documentation is no longer true, +% we now add it below. CORRECT DOCU} +% +% |\mark@restore@state| state is a special output routine those +% only purpose is to reinitialise the state of the mark +% mechanism. Its argument is executed at the of that OR. +% \begin{macrocode} + \mark@restore@state{ +% \end{macrocode} +% Initialising the grabbing trials means putting the saved material +% back onto the MVL and reinitialising the here float list. +% \begin{macrocode} + \unvcopy\@holdpg + \ifnum\saved@outputpenalty > -1073741824\relax + \add@badly@guarded@penalty\output@collect@penalty + \fi + \global\let\@herelist\saved@herelist +% \end{macrocode} +% +% The we can start the actual loop: if we run with floats we go to +% |\trial@inner@loop| otherwise we immediately setup the grap +% column OR. +% \begin{macrocode} + \ifrun@with@floats + \trial@inner@loop + \else + \setup@grab@column@or + \fi + } +%<*trace> + \@tracepop{float@placement@loop} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\trial@inner@loop} +% Alternative entry into the float placement trial loop. This can +% be used by setting |\@activelist@empty@action| and +% |\pretests@success@action| to different values, e.g., for trying +% float pages without the overhead of the grabcolumn output +% routine, etc. +% \begin{macrocode} +\def\trial@inner@loop{ +%<*trace> + \@tracepush{trial@inner@loop} +%</trace> +% \end{macrocode} +% If |\if@fail| is true we have already tried the current float +% before. This means we either do a retry with relaxed conditions +% (in which case the current area to try was suitably modified +% beforhand) or else we have just started with a new float and +% should try the first area of |\this@open@areas|. +% \begin{macrocode} + \if@fail + \@failfalse + \@flushfailfalse +% \end{macrocode} +% +% \begin{macrocode} +%<*progress> + \global\advance\trial@count\@ne +%</progress> +% \end{macrocode} +% +% \begin{macrocode} + \do@next\try@this@area + \else + \do@next\try@next@float + \fi +%<*trace> + \@tracepop{trial@inner@loop} +%</trace> + \do@continue + } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\trial@count} +% To gather statistics we count the number of trials per page. +% \begin{macrocode} +%<*progress> +\newcount\trial@count +%</progress> +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\try@this@area} +% |\try@this@area| is |\let| to the right definition before it is +% called so on top-level it is defined to be an error. +% \begin{macrocode} +\let\try@this@area\ERROR +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\try@next@area} +% |\try@next@area| first updates |\this@open@areas| by removing the +% first area in this list and then calls |\try@this@area|. Thus it +% should never be called if |\this@open@areas| is already empty. +% \begin{macrocode} +\def\try@next@area{ + \xdef\this@open@areas{\expandafter\@gobblethree\this@open@areas} +%<*progress> + \global\advance\trial@count\@ne +%</progress> + \try@this@area +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\try@next@float} +% If there is still a float on the active list take it and try to +% place it in the next open float area (which will be the same as +% the current area after a successful trial). If there are no +% floats left execute |\best@trial| to return to that state then +% switch to the bestcolumn output routine to begin typesetting +% columns. +% \begin{macrocode} +\def\try@next@float{ +%<*trace> + \@tracepush{try@next@float} +%</trace> + \@next\@currbox\@activelist{ +%<*trace> + \tr@ce{currbox:~ \@currbox} +%</trace> +%<*progress> + \progress{Float:~ \@currbox} +%</progress> + \expandafter\update@this@float@structure\the\toks\@currbox +%<*trace> + \tr@ce{saved@this@open@areas~(init):~ + \saved@this@open@areas\space :=~\this@open@areas} +%</trace> + \global\let\saved@this@open@areas\this@open@areas +%<*progress> + \global\advance\trial@count\@ne +%</progress> + \try@this@area + } +% \end{macrocode} +% no floats left\ldots +% \begin{macrocode} + { +%<*progress> + \progress@nl{STATS:~ trials~ =~ \the\trial@count} + \global\trial@count\z@ +%</progress> + \@activelist@empty@action + } +%<*trace> + \@tracepop{try@next@float} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\update@this@float@structure} +% Each float box has an associated token register storing several +% information fields. +% \begin{enumerate} +% \item[1] float caption (set by caption command) +% \item[2] Currently unused (could have callout page number, set by +% |\best@column@or|). +% \item[3] saved label string +% \item[4] `user counter' number (per-type count) set by float environment. +% \item[5] Allowed float areas (from default or optional arg.) +% \item[6] float type (currently this is the long name, eg figure) should +% probably be the single token name, to allow quicker testing. +% \item[7] float sequence number. +% \end{enumerate} +% +% This macro assumes that |\@currbox| is the box number for this structure +% \begin{macrocode} +\def\update@this@float@structure#1#2#3#4#5#6#7{ + \gdef\this@caption{#1} + \gdef\this@span@number{#2} + \gdef\this@usercnt{#4} + \gdef\this@fps{#5} + \gdef\this@type{#6} +% \end{macrocode} +% From the type we infer the class: +% \begin{macrocode} + \global\expandafter\let\expandafter + \this@class\csname sequence@class@#6\endcsname + \gdef\this@sequence@number{#7} +% \end{macrocode} +% If we want to consider all areas for each float (and storing +% closed areas via |\closed@|\meta{type}|@areas| we have to +% initialise |\this@open@areas| to |\used@areas| (which is +% derived from the |area-list| key. +% \begin{macrocode} + \global\let\this@open@areas\used@areas +% \end{macrocode} +% +% \begin{macrocode} + \global\expandafter\let\expandafter\this@closed@areas + \csname closed@\this@class @areas\endcsname % FMi tmp + \global\let\this@float@box\@currbox +%<*trace> +\tr@ce{This~float~structure:} +\toks@{#1}\tr@ce{~{\the\toks@}} +\tr@ce{~{#2}} +\tr@ce{~{#3}} +\tr@ce{~{#4}} +\tr@ce{~{#5}} +\tr@ce{~{#6}} +\tr@ce{~{#7}} +\tr@ce{~this@open@areas~ <-~ \this@open@areas} +\tr@ce{~this@closed@areas~ <-~ \this@closed@areas} +%</trace> +%<*progress> +\progress{~{#7}} +\progress{~{#6}~(\this@class)} +\progress{~{#4}} +%\progress{~{#2}} +%\progress{~{#3}} +%\progress{~{#5}} +\toks@{#1}\progress@nl{~{\the\toks@}} +%</progress> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\extract@this@float@actual@structure} +% As used by Chris in xo-final. Should probably be replaced by the +% one above or combined with the one above!\footnote{FIX!!} +% \begin{macrocode} +\def \extract@this@float@actual@structure #1#2#3#4#5#6#7 { + \gdef\this@caption{#1} + \gdef\this@span@number{#2} + \gdef\this@loglabel{#3} + \gdef\this@usercnt{#4} + \gdef\this@fps{#5} + \gdef\this@type{#6} + \global\expandafter\let\expandafter + \this@class\csname sequence@class@#6\endcsname + \gdef\this@sequence@number{#7} + } +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\update@here@float@structure} +% +% Similar to |\update@this@float@structure| but filling different +% macros.\footnote{We only need some of those macros, so this +% should be cleaned up at some stage.} +% +% This macro assumes that |\@currbox| is the box number for this +% structure. +% +% \begin{macrocode} +\def\update@here@float@structure#1#2#3#4#5#6#7{ + \gdef\here@span@number{#2} + \gdef\here@type{#6} + \global\expandafter\let\expandafter + \here@class\csname sequence@class@#6\endcsname + \gdef\here@sequence@number{#7} + \gdef\here@usercnt{#4} +% \gdef\here@fps{#5} + \gdef\here@caption{#1} + \global\let\here@float@box\@currbox +%<*trace> +\tr@ce{Here~object~structure:} +\toks@{#1}\tr@ce~{~{\the\toks@}} +\tr@ce{~{#2}} +\tr@ce{~{#3}} +\tr@ce{~{#4}} +\tr@ce{~{#5}} +\tr@ce{~{#6}} +\tr@ce{~{#7}} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \begin{macro}{\page@float@count} +% \begin{macrocode} +%\newcount\page@float@count +\let\page@float@count\@colnum +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\this@captioned@float} +% \begin{macrocode} +\newbox\this@captioned@float +% \end{macrocode} +% \end{macro} +% +% +% +% \newpage +% +% \subsection{Grab Column Output Routine} +% +% \begin{description} +% \item[Entry:] |\setup@grab@column@or| +% \item[Exit:] |\setup@cleanup@or| +% \item[Prereq:] +% \item[Description:] +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \setup@grab@column@or +% | +% New OR: \grab@column@or +% | +% V +% \grab@column@loop <------- +% | +% (when entering OR...) +% | +% <end of collection reached?> +% | | +% yes no +% | | +% | <col break requested?> +% | | | +% | yes no +% | | | +% | | <flush point encountered?> +% | | | | +% | | yes no +% | | | | +% | | <flush point <here point encountered?> +% | | too early?> | | +% | | | | yes no +% | | yes no | | +% | | | | ? ? +% | | | (ignore break) +% | | | | +% | | | | +% (end column now) <------- | +% | | +% V | +% <all cols produced?> | +% | | V +% yes no--------------------> (reenter \grab@column@loop) +% | +% (store results of trial) +% | +% V +% \setup@cleanup@or +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% +% +% \begin{macro}{\setup@grab@column@or} +% +% \begin{macrocode} +\def\setup@grab@column@or{ +%<*trace> + \@tracepush{setup@grab@column@or} +%</trace> +% \end{macrocode} +% +% We just returned to the MVL the current galley. We now add a +% special penalty to mark the point that we need to reach in order +% to remove everything after the trial run. +% This penalty has to be guarded against premature removal, e.g., +% if the algorithm would break exactly before it it would then be +% discarded which we can't allow.\footnote{Penalty now added +% earlier (normally). CORRECT DOCU} +% \begin{macrocode} + \ifnum\saved@outputpenalty = -1073741824\relax + \add@badly@guarded@penalty\output@collect@penalty + \fi +% \end{macrocode} +% +% \begin{macrocode} + \@failfalse + \global\curr@col@count\z@ +% \end{macrocode} +% In case there is a flush penalty in the collection we have to +% find out if we see it again during the trial. So we record the +% number of flush points we see during the trial. Same happens for +% here points. +% \begin{macrocode} + \gdef\trial@flush@seen@num{0} + \gdef\trial@here@seen@num{0} +% \end{macrocode} +% +% Moved from |\try@this@area| as it should be executed +% only if we really do a trial and thus back it out if +% unsuccessful---this was a bug as it changed +% |\fl@|\meta{col}|@|\meta{type} in cases we never came to this +% point here but recursed) +% \begin{macrocode} + \ifrun@with@floats +% \end{macrocode} +% Depending on the policy a spanning float can be considered belong +% to different columns. This influences the behaviour of the +% call-out contraint tests and is determined by the code stored in +% |\calculate@target@fl@column|. +% \begin{macrocode} + \calculate@target@fl@column +% \end{macrocode} +% |\calculate@target@fl@column| returns its calculated column +% number in |\count@|. +% \begin{macrocode} + \global\expandafter\let\expandafter\saved@fl@ + \csname fl@\the\count@ @\this@class\endcsname + \global\expandafter\let + \csname fl@\the\count@ @\this@class\endcsname + \this@sequence@number +%<*trace> + \tr@ce{~fl@\the\count@ @\this@class\space <-~ + \csname fl@\the\count@ @\this@class\endcsname} +%</trace> +% \end{macrocode} +% If we are adding to a top area we also have to update the +% corresponding |tfl@| commands: +% \begin{macrocode} + \if t\this@area@type + \global\expandafter\let\expandafter\saved@tfl@ + \csname tfl@\the\count@ @\this@class\endcsname + \global\expandafter\let + \csname tfl@\the\count@ @\this@class\endcsname + \this@sequence@number +%<*trace> + \tr@ce{~tfl@\the\count@ @\this@class\space <-~ + \csname tfl@\the\count@ @\this@class\endcsname} +%</trace> + \fi + \fi +% \end{macrocode} +% +% If we have seen any flush points during collection we need to +% save their current |min@col| positions in case we have to throw +% away the current trial. +% \begin{macrocode} + \if@flushseen + \count@\z@ + \@whilenum \flush@seq@num>\count@ \do + { \advance\count@\@ne + \global\expandafter\let + \csname saved@flush@min@col@\the\count@ \expandafter\endcsname + \csname flush@min@col@\the\count@\endcsname +%<*trace> + \tr@ce{saved@flush@min@col@\the\count@ \space <-~ + \csname flush@min@col@\the\count@\endcsname} +%</trace> + } + \fi +% \end{macrocode} +% +% \begin{macrocode} + \initialise@footins@action +% \end{macrocode} +% +% \begin{macrocode} + \global\output{\grab@column@or} + \grab@column@loop +% \end{macrocode} +% +% \begin{macrocode} +%<*trace> + \@tracepop{setup@grab@column@or} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\calculate@target@fl@column} +% \begin{macro}{\calculate@target@fl@column@flexible} +% \begin{macro}{\calculate@target@fl@column@strict} +% The purpose of |\calculate@target@fl@column| is to calculate +% the column number for which the |\fl@|\meta{col}|@number| has to +% be updated in case we place the current float into the area with +% start column |\this@area@col@number| and span-number +% |\this@area@span@number|. It returns the calculated number in +% |\count@|. +% +% For non-spanning floats it is simply returning +% |\this@area@col@number|. If we return this value also in case of +% spanning floats then this means that we claim that the float has +% be placed the first of its spanned columns. Alternatively we +% could return the last of the spanned columns which would if the +% |column| policy is in force, allow to place a float into |t12| +% even if its call-out is in the second column. +% +% The real value for |\calculate@target@fl@column| will be assigned +% in the page setup template. +% \begin{macrocode} +\let\calculate@target@fl@column \ERROR +% \end{macrocode} +% +% And here are the two possibilities. +% \begin{macrocode} +\def\calculate@target@fl@column@flexible { + \count@\this@area@col@number\relax + \advance\count@\this@area@span@number\relax + \advance\count@\m@ne +} +% \end{macrocode} +% +% \begin{macrocode} +\def\calculate@target@fl@column@strict { + \count@\this@area@col@number\relax +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\ifrun@with@floats} +% \begin{macro}{\run@with@floatstrue} +% \begin{macro}{\run@with@floatsfalse} +% +% \begin{macrocode} +\newif\ifrun@with@floats +\def\run@with@floatsfalse{\global\let\ifrun@with@floats\iffalse} +\def\run@with@floatstrue{\global\let\ifrun@with@floats\iftrue} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\grab@column@loop} +% The |\grab@column@or| output routine is responsible for +% constructing one column of a layout trial. The loop command +% increments the column count and sets vsize to the target height +% for the current column (which has already been set based on the +% size and position of the floats in this trial layout. +% \begin{macrocode} +\def\grab@column@loop{ +%<*trace> + \@tracepush{grab@column@loop} +%</trace> + \global\advance\curr@col@count\@ne + \global\vsize\csname col@ht@ \the\curr@col@count\endcsname +%<*trace> + \@tracepop{grab@column@loop} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \begin{macro}{\some@column@or} +% |\grab@column@or| and |\best@column@or| are sharing most of their +% code which is therefore placed into a separate macro. At the +% moment it takes 4 arguments: the name (``grab'' or ``best''), +% what to do when we actually finish the column +% (``|\grab@column@or@finish|'' or ``|\best@column@or@finish|''), +% what to do for a flush point, and what to do when we encounter a +% here float.\footnote{This code needs a bit of redesign to deal +% properly with the case that we have stumbled upon one of the +% special penalties. In this case we need to ensure that we also +% remove the special box after the penalty in case we are at a +% column break. This is not done right now so that in this case we +% will not dicard material at the top of the column properly. FIX!!!!} +% \begin{macrocode} +\def\some@column@or #1#2#3#4{ +%<*trace> + \@tracepush{#1@column@or} + \tr@ce{output~pen:~ \the\outputpenalty} + \tr@ce{#1~ col:~ \the\curr@col@count\space of~ \the\col@count} +%</trace> + \handle@case@of@premature@ending + \handle@case@of@forced@pagebreak +% \end{macrocode} +% If the |\outputpenalty| is |-\output@flush@float@penalty| we +% have reached a float flush point in the galley. +% \begin{macrocode} + \ifnum\outputpenalty=-\output@flush@float@penalty + \gincrement@num\trial@flush@seen@num +%<*trace> + \tr@ce{flush~ point~(\trial@flush@seen@num,~ + affects:~ \csname flush@classes@list@\trial@flush@seen@num\endcsname,~ + mincol:~ \csname flush@min@col@\trial@flush@seen@num\endcsname,~ + lastfloat:~ \csname flush@last@float@\trial@flush@seen@num\endcsname + )~ reached} +%</trace> +% \end{macrocode} +% We then remove the guard box from the output (which is at the end +% of box |\@cclv|. +% \begin{macrocode} + \remove@guard@box@from@cclv +% \end{macrocode} +% If the flush penalty moved to an earlier column than in the last +% trial we end the current column (by calling +% |\#1@column@or@finish|) and reinsert the penalty so that it will +% be seen again if we do the next column. +% \begin{macrocode} + \ifnum\csname flush@min@col@\trial@flush@seen@num\endcsname + > \curr@col@count +%<*trace> + \tr@ce{flush@min@col@\trial@flush@seen@num\space >~ + curr@col@count~ + (\csname flush@min@col@\trial@flush@seen@num\endcsname + \space >~ \the\curr@col@count)~ ->~ ending~ column} +%</trace> + \gdecrement@num\trial@flush@seen@num + \readd@guarded@penalty\output@flush@float@penalty + #2 + \else +% \end{macrocode} +% Otherwise the flush point is in an acceptable position which +% means we ignore it and carry on collecting material for the +% current column. This is done be putting everything back onto the +% MVL except the guard box and the penalty.\footnote{We lose a +% potential break point here (acceptable?) See comments in +% best@column@or!!} +% \begin{macrocode} +%<*trace> + \tr@ce{flush@min@col@\trial@flush@seen@num\space + <=~ curr@col@count~ + (\csname flush@min@col@\trial@flush@seen@num\endcsname + \space <=~ \the\curr@col@count)} +%</trace> +% \end{macrocode} +% What exactly happens here (beside the above) depends on the +% calling macro. +% \begin{macrocode} + #3 + \fi + \else +% \end{macrocode} +% If it was not a flush point we might have a here point to take +% care of. This is more or less like the code above. +% \begin{macrocode} + \ifnum\outputpenalty=-\output@here@float@penalty + \gincrement@num\trial@here@seen@num +%<*trace> + \tr@ce{here~ penalty~(\trial@here@seen@num)~ reached} +%</trace> + \remove@guard@box@from@cclv + \ifnum\csname here@min@col@\trial@here@seen@num\endcsname + > \curr@col@count +%<*trace> + \tr@ce{here@min@col@\trial@here@seen@num\space >~curr@col@count~ + (\csname here@min@col@\trial@here@seen@num\endcsname + \space >~ \the\curr@col@count)~ ->~ ending~ column} +%</trace> + \split@off@last@line + \gdecrement@num\trial@here@seen@num + \readd@guarded@penalty\output@here@float@penalty + #2 + \else + \@tempdima \pagegoal + \advance\@tempdima -\pagetotal + \ifdim \@tempdima < + \csname + here@required@space@\trial@here@seen@num + \endcsname \relax +%<*trace> + \tr@ce{here@required@space@\trial@here@seen@num\space >~ + \pagegoal-\pagetotal \space + (\csname here@required@space@\trial@here@seen@num\endcsname + \space >~ \the\pagegoal\space + -~ \the\pagetotal\space =~ + \the\@tempdima)~ + ->~ ending~ column} +%</trace> + \split@off@last@line + \gdecrement@num\trial@here@seen@num + \readd@guarded@penalty\output@here@float@penalty + #2 + \else +%<*trace> + \tr@ce{here@required@space@\trial@here@seen@num\space <=~ + \pagegoal-\pagetotal \space + (\csname here@required@space@\trial@here@seen@num\endcsname + \space <=~ \the\pagegoal\space + -~ \the\pagetotal\space =~ + \the\@tempdima)~ + ->~ accepting~ here~ point} +%</trace> + \@reinserts + \unvbox\@cclv + \@next\@currbox\@herelist{ +%<*trace> + \tr@ce{@currbox:~ \@currbox} +%</trace> + \expandafter\update@here@float@structure\the\toks\@currbox +% \end{macrocode} +% Different things need to be done depending on the type of the +% here point: +% \begin{macrocode} + \def\@tempa{mpar} + \ifx\@tempa\here@type + \typeset@a@marginpar + \else + \def\@tempa{rspace} + \ifx\@tempa\here@type + % do nothing + \else + #4 + \fi + \fi + } +% \end{macrocode} +% If there is no here object left the algorithm has screwed up +% (i.e., a ``this can't happen'' situation). +% \begin{macrocode} + \ERROR + \fi + \fi + \else +% \end{macrocode} +% If it is neither a flush nor a here point it might be a grid point: +% \begin{macrocode} + \ifnum\outputpenalty=-\output@grid@align@penalty + \align@collected@galley@and@restart +% \end{macrocode} +% So we now know that it wasn't one of our special points so this +% must have been a normal end of the galley: +% \begin{macrocode} + \else + #2 + \fi + \fi + \fi +%<*trace> + \@tracepop{#1@column@or} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\grab@column@or} +% Here is the output routine used during trials, an instantiation +% of |\some@column@or|. +% \begin{macrocode} +\def\grab@column@or{\some@column@or{grab} + \grab@column@or@finish + \grab@column@or@flushcheck + \check@and@typeset@a@here@float +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\grab@column@or@flushcheck} +% +% The |\grab@column@or@flushcheck| code checks for restrictions +% regarding the placement of the current float. It is called when +% we just have encountered a flush float penalty while grabbing the +% text for a column and now have to see which floats (if any) need +% to be positioned before that flush point. +% \begin{macrocode} +\def\grab@column@or@flushcheck{ +%<*trace> + \@tracepush{grab@column@or@flushcheck} +%</trace> +% \end{macrocode} +% If we are making a dry-run without floats then there is no need to +% do much, so we skip all testing that involves flush points and +% only do the cleanup actions at the end. +% \begin{macrocode} + \ifrun@with@floats + \expandafter\xin@\expandafter\this@class + \csname flush@classes@list@\trial@flush@seen@num\endcsname + \ifin@ +%<*trace> + \tr@ce{flush:~ class~ \this@class\space in~ + {\csname flush@classes@list@\trial@flush@seen@num\endcsname}} +%</trace> +% \end{macrocode} +% We store in |\count@| the float sequence number of the last float +% that would be affected by the current flush penalty. This value +% is then used in the tests below. +% \begin{macrocode} + \count@\csname flush@last@float@\trial@flush@seen@num\endcsname\relax +% \end{macrocode} +% +% If the current float number is higher than float number stored in +% |\flush@last@float@|\meta{num} with the flush penalty, we are +% dealing with a float whose call-out is after the flush penalty +% and thus we have no restriction. +% \begin{macrocode} + \ifnum\this@sequence@number>\count@ +%<*trace> + \tr@ce{???:\this@sequence@number>\the\count@} + \tr@ce{this~float~ past~flush~point} +%</trace> + \else +% \end{macrocode} +% Otherwise check if this float is placed in an acceptable position +% with respect to the current flush point. For this we run +% different code depending on the ``fuzziness'' of the flush point +% under check: +% \begin{macrocode} + \csname flush@fuzziness@\trial@flush@seen@num \endcsname + \fi +%<*trace> + \else + \tr@ce{flush:~ class~ \this@class\space not~ in~ + {\csname flush@classes@list@\trial@flush@seen@num\endcsname}} +%</trace> + \fi + \fi +% \end{macrocode} +% If we failed above we additionally record that the failure is +% due to violating restrictions for a flush point. +% \begin{macrocode} + \if@fail + \@flushfailtrue +% \end{macrocode} +% +% \begin{macrocode} + \global\setbox\@cclv\box\voidb@x + \global\setbox\footins\box\voidb@x +% \end{macrocode} +% We have to immediately abort the current trial otherwise a +% flush point following in the galley might be encountered and +% processed before we reach |\evaluate@results@of@trial|. That +% would result in updating the wrong data structure there (due to +% the fact that there it assumes that |\trial@flush@seen@num| +% refers to the flush point that is the reason for +% failure).\footnote{Implementation could be improved!} +% \begin{macrocode} + \global\curr@col@count\col@count + \grab@column@or@finish + \else +% \end{macrocode} +% If we haven't failed we might have to update the +% |\flush@min@col|\meta{num} for the current flush point in case it +% moved to a new column. +% \begin{macrocode} + \ifnum\csname flush@min@col@\trial@flush@seen@num\endcsname<\curr@col@count + \expandafter\xdef + \csname flush@min@col@\trial@flush@seen@num\endcsname + {\the\curr@col@count} +%<*trace> + \tr@ce{set~ flush@min@col@\trial@flush@seen@num:~ + \csname flush@min@col@\trial@flush@seen@num\endcsname} +%</trace> + \fi +% \end{macrocode} +% We have to return the collected footnotes first or else \TeX{} +% might decide that it is better to break before +% them.\footnote{Quite likely that this needs some refinement as it +% might mess up vertical spacing in other respects. Look out for +% other places where \texttt{\string\@reinserts} is used, if this +% needs fixing.} +% \begin{macrocode} + \@reinserts + \unvbox\@cclv +% \end{macrocode} +% What penalty to return???\footnote{FIX!!!} +% \begin{macrocode} +% \penalty\z@ % none i think now (in the current version) but this + % will change again + \fi +%<*trace> + \@tracepop{grab@column@or@flushcheck} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\flushcheck@page} +% \begin{macrocode} +\def\flushcheck@page { +%<*trace> + \tr@ce{OK:~flush~check~ (same~page)} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\flushcheck@spread} +% +% This is actually a dummy definition. There is more to do if we +% want to provide support for spreads!\footnote{Finish implementation} +% \begin{macrocode} +\def\flushcheck@spread { +%<*trace> + \tr@ce{OK:~flush~check~ (using~page~not~ spread)} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\flushcheck@strict} +% \begin{macrocode} +\def\flushcheck@strict { +%<*trace> + \@tracepush{flushcheck@strict} +%</trace> +% \end{macrocode} +% If strict flushing is required we look where the current float is +% being placed. If it +% is placed in a column which is earlier than the current column +% then it is definitely before the flush point and thus we are okay. +% \begin{macrocode} + \ifnum\this@area@col@number<\curr@col@count +%<*trace> + \tr@ce{OK:~flush~check~ + (\this@area@col@number<\the\curr@col@count,~\this@area)} +%</trace> + \else +% \end{macrocode} +% Otherwise we test if the float is placed into the current +% column. If this is the case it might be okay, but only if it is +% not placed into the bottom area. +% \begin{macrocode} + \ifnum\this@area@col@number=\curr@col@count +% \end{macrocode} +% To test for the bottom area(s) means looking at the first token +% in the area identifier. If it is |b| we are past the flush +% point.\footnote{It might be an interesting extension to allow +% relaxing the flush situation to allow the floats to appear +% anywhere on the current column (on which the flush point ends up), +% or even allowing that it only has to appear on the current page +% or page spread.} +% \begin{macrocode} + \if b \this@area@type + \@failtrue +%<*progress> + \progress@failed{area~ below~ flush~ point~ + (\this@area@col@number=\the\curr@col@count,~\this@area)} +%</progress> +%<*trace> + \tr@ce{Fail:~flush~check~ + (\this@area@col@number=\the\curr@col@count,~\this@area)} +% \end{macrocode} +% Otherwise the float was placed into an area that is still before +% the flush point. +% \begin{macrocode} + \else + \tr@ce{OK:~flush~check~ + (\this@area@col@number=\the\curr@col@count,~\this@area)} +%</trace> + \fi +% \end{macrocode} +% If the float was neither placed before nor into the current +% column we have to conclude that it was placed into a later column +% which means it was placed after the flush point --- thus we fail. +% \begin{macrocode} + \else + \@failtrue +%<*progress> + \progress@failed{area~ after~ flush~ point~ + (\this@area@col@number>\the\curr@col@count,~\this@area)} +%</progress> +%<*trace> + \tr@ce{Fail:~flush~check~ + (\this@area@col@number>\the\curr@col@count,~\this@area)} +%</trace> + \fi + \fi +%<*trace> + \@tracepop{flushcheck@strict} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\flushcheck@column} +% \begin{macrocode} +\def\flushcheck@column { + \ifnum\this@area@col@number>\curr@col@count + \@failtrue +%<*progress> + \progress@failed{area~ after~ flush~ point~ column~ + (\this@area@col@number>\the\curr@col@count,~\this@area)} +%</progress> +%<*trace> + \tr@ce{Fail:~flush~check~ + (\this@area@col@number>\the\curr@col@count,~\this@area)} + \else + \tr@ce{OK:~flush~check~ + (\this@area@col@number<=\the\curr@col@count,~\this@area)} +%</trace> + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\grab@column@or@finish} +% \begin{macrocode} +\def\grab@column@or@finish{ +%<*trace> + \@tracepush{grab@column@or@finish} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \mark@update@structure +% \end{macrocode} +% +% \begin{macrocode} + \deal@with@footins@action +% \end{macrocode} +% +% First check if there are some special constraints that should be +% met (this is, for example, used to check if there are both bottom +% floats and footnotes). If the constraints are not met don't +% bother to check the callout/float constraints. +% \begin{macrocode} + \if@fail\else + \ifrun@with@floats + \check@some@constraints + \fi + \fi + \if@fail\else +% \end{macrocode} +% For each float sequence class, call |\check@callout@constraints| +% this will be set via a call to a pagesetup template to do an +% appropriate check on the float placement relative to float +% call-out. +% \begin{macrocode} + \ifrun@with@floats + \let\@elt\check@callout@constraints + \float@classes@list + \fi + \fi +% \end{macrocode} +% +% Throw the text away (it will be reset later if this trial is +% in fact chosen). +% \begin{macrocode} + \global\setbox\@cclv\box\voidb@x + \global\setbox\footins\box\voidb@x +% \end{macrocode} +% After the last column we evaluate the results of the trial (and +% if the result looks ok remember it as a candidate for the final +% solution). We then switch to the `clean up' OR which will +% collect up the main vertical list as far as the special penalty +% marking the end of the collection pass, to clear the MVL for the +% next trial. If this isn't the last column, set up the next +% column. +% \begin{macrocode} + \ifnum\curr@col@count=\col@count + \evaluate@results@of@trial + \setup@cleanup@or + \else + \grab@column@loop + \fi +%<*trace> + \@tracepop{grab@column@or@finish} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\handle@case@of@premature@ending} +% Next |\ifnum| is a fix that needs rethinking: what is the best +% approach if we hit the penalty which denotes the end of the +% collected galley too early, e.g., in the middle of a trial using +% |\grab@column@or| or when producing the final columns with +% |\best@column@or|? Current solution gets the stuff out, but is it +% probably not the best solution. +% correct? +% \begin{macrocode} +\def\handle@case@of@premature@ending{ + \ifnum\outputpenalty=-\output@collect@penalty + \remove@guard@box@from@cclv + \readd@guarded@penalty\output@collect@penalty + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\check@some@constraints} +% By default there are no additional constraints to check for. +% \begin{macrocode} +\let\check@some@constraints\relax +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\evaluate@results@of@trial} +% +% The purpose of |\evaluate@results@of@trial| is to determine if +% the current trial is a potential candiate for the final solution +% and if so store it away. We can determine if the trial failed by +% looking at the switch |@fail|. +% \begin{macrocode} +\def\evaluate@results@of@trial{ +%<*trace> + \@tracepush{evaluate@results@of@trial} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \ifrun@with@floats + \ifx\try@this@area\std@try@this@area + \count@\trial@here@seen@num\relax + \advance\count@\page@float@count + \ifnum \pagesetup@max@float@num < \count@ +%<*trace> + \tr@ce{Failed:~ area~ +~ here~ floats~ exceed~ max~ floats} +%</trace> +%<*progress> + \progress@failed{area~ +~ here~ floats~ exceed~ max~ floats} +%</progress> + \@failtrue + \fi + \fi + \fi +% \end{macrocode} +% +% \begin{macrocode} + \if@fail +%<*trace> + \tr@ce{fail:~true} +%</trace> +% \end{macrocode} +% If the trial has failed we have to distinguish two cases: +% \begin{itemize} +% \item +% There has been a request for flushing out floats up to a +% certain float somewhere +% and the current float belongs to the list of floats to flush. +% \item +% There has been no such request. +% \end{itemize} +% +% If there have been flush points we need to restore their +% |min@col| values since we might have updated them. +% \begin{macrocode} + \if@flushseen + \count@\z@ + \@whilenum \flush@seq@num>\count@ \do + { \advance\count@\@ne + \global\expandafter\let + \csname flush@min@col@\the\count@ \expandafter\endcsname + \csname saved@flush@min@col@\the\count@\endcsname +%<*trace> + \tr@ce{flush@min@col@\the\count@ \space <-~ + \csname flush@min@col@\the\count@\endcsname \space + (restore) } +%</trace> + } + \fi + + \if@flushfail +%<*trace> + \tr@ce{flushfail:~true} +%</trace> +% \end{macrocode} +% If we have failed and |\try@this@area| is already the ``relaxed'' +% version we have to artificially move the offending flush point to +% the next column and hope that this way we get ourselves some new +% options (worst case is that eventually the flush point is removed +% from the page in which case we can as a last resort defer the +% float). +% \begin{macrocode} + \ifx\try@this@area\relaxed@try@this@area + + \expandafter\gincrement@num + \csname flush@min@col@\trial@flush@seen@num\endcsname +%<*trace> + \tr@ce{flush@min@col@\trial@flush@seen@num~ <-~ + \csname flush@min@col@\trial@flush@seen@num\endcsname} +%</trace> +%<*progress> + \progress@failed{flush~ point~ \trial@flush@seen@num\space + moved~ to~ column~ + \csname flush@min@col@\trial@flush@seen@num\endcsname} +%</progress> + \else + + \ifx\saved@this@open@areas\@empty +%<*debug> + \tr@ce{saved@this@open@areas:~empty ????????} +%</debug> + \ERROR + \else + \global\let\this@open@areas\saved@this@open@areas +%<*trace> + \tr@ce{~this@open@areas~ <-~ \this@open@areas \space (reopen)} +%</trace> + \fi + \relax@float@placement@conditions + \fi + \else +%<*trace> + \tr@ce{flushfail:~false} +%</trace> + \xdef\this@open@areas{\expandafter\@gobblethree\this@open@areas} + \fi + +%<*trace> + \tr@ce{open:~\this@open@areas} + + \tr@ce{restore:~last~allocated:~\saved@fl@} +%</trace> +% \end{macrocode} +% To restore the previous state we have to recalculate the target +% |fl@| column. +% \begin{macrocode} + \calculate@target@fl@column + \global\expandafter\let + \csname fl@\the\count@ @\this@class\endcsname + \saved@fl@ +%<*trace> + \tr@ce{~fl@\the\count@ @\this@class\space <-~ + \saved@fl@ \space (restored)} +%</trace> +% \end{macrocode} +% And if we tried a top area we also have to restored the +% corresponding |tfl@| macro. +% \begin{macrocode} + \if t\this@area@type + \global\expandafter\let + \csname tfl@\the\count@ @\this@class\endcsname + \saved@tfl@ +%<*trace> + \tr@ce{~tfl@\the\count@ @\this@class\space <-~ + \saved@tfl@ \space (restored)} +%</trace> + \fi +% \end{macrocode} +% And we better don't forget to restore the heights.\footnote{This +% is most likely buggy: I seem to restore all column values but i think +% i don't save all of them! FIX!!!!} +% \begin{macrocode} + \update@this@area@columns + { +%<*trace> + \tr@ce{restore:~saved@col@ht@ \the\count@:~ + \csname saved@col@ht@ \the\count@\endcsname} +%</trace> + \global\csname col@ht@ \the\count@\endcsname + \csname saved@col@ht@ \the\count@\endcsname\relax + \global\expandafter\let + \csname col@ \this@area@type @delta@ \the\count@ + \expandafter \endcsname + \csname saved@col@ \this@area@type @delta@ \the\count@ \endcsname +%<*trace> + \tr@ce{GRID (delta):~ column~\the\count@\this@area@type:~ + \csname saved@col@ \this@area@type @delta@ \the\count@ + \endcsname\space (restore) } +%</trace> + } + \else +%<*trace> + \tr@ce{fail:~false} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} +%<*progress> + \let\progress@inform@later\@empty +%</progress> +% \end{macrocode} +% If this trial is valid and we haven't seen all flush penalties +% again we must have pushed them to the next page. We record +% this fact by setting |flush@min@col@...| to |\maxdimen|. +% \begin{macrocode} + \if@flushseen + \count@\flush@seq@num\relax + \loop + \ifnum \trial@flush@seen@num < \count@ + \global\@namedef{flush@min@col@\the\count@}{\maxdimen} +%<*trace> + \tr@ce{flush@min@col@\the\count@\space <-~ maxdimen} +%</trace> + \advance\count@\m@ne + \repeat +% \end{macrocode} +% If there has been a flush point (ie if |\trial@flush@seen@num| und +% thus |\count@| is greater than 0) we test whether or not the +% float recently placed was the last one affected by the last flush +% point on the current page and if so tighten the float placement +% setting again.\footnote{correct logic?} +% \begin{macrocode} +%<*progress> + \let\progress@inform@later\@empty +%</progress> + \ifrun@with@floats + \ifnum \count@ > \z@ + \ifnum \csname flush@last@float@\trial@flush@seen@num\endcsname = + \this@sequence@number \relax +%<*trace> + \tr@ce{flush:~ last~float~affected~ by~ flush~ point~ + \trial@flush@seen@num\space placed~ ->~ + use~ partly~ normal~ placement~ conditions~ again} +%</trace> +%<*progress> + \def\progress@inform@later{ + \progress@nl{->~ past~ flush~ point:~ -->~ + tighten~ conditions~ again} + \progress@nl{} + } +%</progress> + \partly@tighten@float@placement@conditions + \fi + \fi + \fi +% \end{macrocode} +% Having placed a float we need to update |\flush@classes@list@max| to +% reflect which float types are affected by the flush points +% currently on the page as this might be needed when trying to +% place or rather defer the next float. +% +% So we loop and concatenate all |\flush@classes@list@|\meta{num} that +% belong to flush points on the current page. This might result in +% the list containing types several times but for the test we need +% to do this doesn't make any difference (and it is far faster than +% unifying the list). +% \begin{macrocode} + \count@\z@ + \global\let\flush@classes@list@max\@empty + \loop + \ifnum \trial@flush@seen@num > \count@ + \advance\count@\@ne + \xdef\flush@classes@list@max{ + \flush@classes@list@max; + \csname flush@classes@list@\the\count@\endcsname + } +%<*trace> + \tr@ce{flush@classes@list@max~ <-~ \flush@classes@list@max} +%</trace> + \repeat + \fi +% \end{macrocode} +% +% With this algorithm a trial which passed so far is always +% considered to be better than previous trials (meaning more floats +% on the page are better). So we always update the best trial data +% (unless this was the run without adding floats in which case we +% only change the |run@with@floats| switch. +% \begin{macrocode} + \ifrun@with@floats + \update@best@trial +%<*progress> + \progress@inform@later +%</progress> + \else + \run@with@floatstrue + \fi + \fi +%<*trace> + \@tracepop{evaluate@results@of@trial} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Best Trial Data} +% +% +% \begin{macro}{\best@trial} +% \begin{macrocode} +\let\best@trial\@empty +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\update@best@trial} +% Not all of this belongs into this macro!\footnote{redistribute} +% \begin{macrocode} +\def\update@best@trial{ +%<*trace> + \@tracepush{update@best@trial} +%</trace> +%<*progress> + \progress@nl{->~ accepted} +%</progress> + \global\let\best@trial\@empty + \forall@columns{ + \expandafter + \g@addto@macro\expandafter\best@trial\expandafter + { + \expandafter + \global + \csname col@ht@ \the\curr@col@count\expandafter\endcsname + \the\csname col@ht@ \the\curr@col@count\endcsname + } + } +% \end{macrocode} +% +% Frank says this needs to be documented (the rest of the code is self evident) +% |\this@float@box| is |\let| to |\@currbox| which is defed to a chardefed +% token from newinsert. so this is OK. honest. +% \begin{macrocode} + \expandafter\@cons\csname area@\this@area\expandafter\endcsname + \this@float@box +% \end{macrocode} +% +% \begin{macrocode} +%<*trace> + \tr@ce{this@page@closed~ \this@page@closed\space +~ + "\csname pagesetup@\this@area @all@close\endcsname"} + \tr@ce{this@closed@areas~ \this@closed@areas\space +~ + "\csname pagesetup@\this@area @class@close\endcsname"} +%</trace> + \xdef\this@page@closed{\this@page@closed, + \csname pagesetup@\this@area @all@close\endcsname} + \xdef\this@closed@areas{\this@closed@areas, + \csname pagesetup@\this@area @class@close\endcsname} +% \end{macrocode} +% +% \begin{macrocode} + \global\expandafter\let\csname open@\this@class + @areas\endcsname % FMi tmp + \this@open@areas + \global\expandafter\let\csname closed@\this@class + @areas\endcsname % FMi tmp + \this@closed@areas +% \end{macrocode} +% moving the captioned float to the main float box is put into a +% separate macro so that we can suppress this in cases where we +% potentially want to revert to a previous stage.\footnote{FIX} +% \begin{macrocode} +%<*obsolete> + \add@caption@to@float@box +%</obsolete> +% \end{macrocode} +% +% \begin{macrocode} + \global\advance\page@float@count\@ne + \global\advance\csname \this@area @float@count\endcsname\@ne +% \end{macrocode} +% +% Since the trial was successful, we have to update the the macros +% that hold the number of top or bottom floats we have seen so far +% in each column.\footnote{Code for this is similar to the one in +% construct@and@test@col@ht and elsewhere; perhaps there should be +% a subroutine for it!} +% \begin{macrocode} + \update@this@area@columns + { + \expandafter + \gincrement@num + \csname col@ \this@area@type + @floats@ \the\count@ @number\endcsname +%<*trace> + \tr@ce{col@ \this@area@type + @floats@ \the\count@ @number <-~ + \csname col@ \this@area@type + @floats@ \the\count@ @number\endcsname} +%</trace> + } +% \end{macrocode} +% +% \begin{macrocode} +%<*trace> + \tr@ce{\meaning\best@trial} + \tr@ce{area:~\this@area\space\csname area@\this@area\endcsname} + \@tracepop{update@best@trial} +%</trace> +} +% \end{macrocode} +% \end{macro} +% + +% \begin{macro}{\add@caption@to@float@box} +% This is a hook really to be able to prevent moving the caption +% back into |\this@float@box| (by making this macro |\relax| and +% this is what happens later on in xo-final). Yes we know the +% coding here needs changing!\footnote{David FIX!!!} +% \begin{macrocode} +%<*obsolete> +\def\add@caption@to@float@box{ + \global\setbox\this@float@box\box\this@captioned@float +} +%</obsolete> +% \end{macrocode} +% \end{macro} +% +% +% \newpage +% +% \subsection{Best Column Output Routine} +% +% \begin{description} +% \item[Entry:] |\setup@best@column@or| +% \item[Exit:] |\setup@collection@or| +% \item[Prereq:] +% \item[Description:] +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \setup@best@column@or +% | +% New OR: \best@column@or +% | +% V +% \best@column@loop <------- +% | +% (when entering OR...) +% | +% <end of collection reached?> +% | | +% yes no +% | | +% | <col break requested?> +% | | | +% | yes no +% | | | +% | | <flush point encountered?> +% | | | | +% | | yes no +% | | | | +% | | <flush point <here point encountered?> +% | | too early?> | | +% | | | | yes no +% | | yes no | | +% | | | | ? ? +% | | | (ignore break) +% | | | | +% | | | | +% | | | | +% | | | | +% | | | | +% | | | | +% | | | | +% | | | | +% | | | | +% (end column now) <------- | +% | | +% V | +% <all cols produced?> | +% | | V +% yes no--------------------> (reenter \best@column@loop) +% | +% (produce final page) +% | +% V +% \initialise@next@page +% | +% V +% (try to make float pages) +% | +% V +% \setup@collection@or +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% +% After the best trial is chosen the `best@column@or' output routines +% are executed. Structurally this is similar to the grab column output +% routines used during the trials, but this time information +% about the float placements is recorded in the float area lists +% and also optionally in float placement control files. +% +% \begin{macro}{\setup@best@column@or} +% This is the initialisation code for producing the final best set +% of columns (via the @best@column@or output routine). +% \begin{macrocode} +\def\setup@best@column@or{ +%<*trace> + \@tracepush{setup@best@column@or} +% Elsewhere now: +% \tr@ce{reinsert~penalty:~ \saved@outputpenalty\space (unless~ 10000)} +%</trace> +% \penalty +% \ifnum\saved@outputpenalty=\@M +% \z@ +% \else +% \saved@outputpenalty\relax +% \fi + \global\curr@col@count\z@ + \gdef\trial@flush@seen@num{0} + \gdef\trial@here@seen@num{0} + \perhaps@write@placements@to@fpl@file + \best@trial +% \end{macrocode} +% +% \begin{macrocode} + \initialise@footins@action +% \end{macrocode} +% +% \begin{macrocode} + \global\output{\best@column@or} + \best@column@loop +%<*trace> + \@tracepop{setup@best@column@or} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\best@column@loop} +% \begin{macrocode} +\def\best@column@loop{ +%<*trace> + \@tracepush{best@column@loop} +%</trace> + \global\advance\curr@col@count\@ne + \global\vsize\csname col@ht@ \the\curr@col@count\endcsname +%<*trace> + \tr@ce{vsize~ <-~ \the\vsize } + \@tracepop{best@column@loop} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\best@column@or} +% Here is the output routine used when preparing the final columns, +% an instantiation of |\some@column@or|. In contrast to the version +% used for |\grab@column@or| it doesn't do the tests. +% \begin{macrocode} +\def\best@column@or{\some@column@or{best} + \best@column@or@finish + { + \@reinserts + \unvbox\@cclv +% \end{macrocode} +% Next line not okay! we need to add a penalty here but which one? +% Or we need a different mechanism using either |\holdinginserts| +% or a partial box line in collection OR.\footnote{FIX!!! there is +% also another place like this!} +% \begin{macrocode} +% \penalty\z@ %FMi? + } + { + \perhaps@write@to@fpl@file{ + \@spaces Area:~hhh^^J + \expandafter\perhaps@write@placements@to@fpl@file@aux\the\toks\@currbox} + \typeset@a@here@float + } +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \begin{macro}{\best@column@or@finish} +% +% \begin{macrocode} +\def\best@column@or@finish{ +%<*trace> + \@tracepush{best@column@or@finish} +%</trace> + \mark@update@structure +% \end{macrocode} +% +% \begin{macrocode} + \deal@with@footins@action +% \end{macrocode} +% +% save all marks here\footnote{not done yet!} +% +% add floats and footnotes etc to collected column +% +% \begin{macrocode} + \produce@final@column +% \end{macrocode} +% +% \begin{macrocode} + \ifnum\curr@col@count=\col@count + \produce@final@page + \initialise@next@page + \try@float@pages + \place@deferred@floats + \setup@collection@or +%{\showoutput\showlists} + \else + \best@column@loop + \fi +%<*trace> + \@tracepop{best@column@or@finish} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\initialise@next@page} +% Initialises the column heights to text height. Clear the float +% area lists, zero holdinginserts to allow footnote texts to arrive +% in the insertion box. +% \begin{macrocode} +\def\initialise@next@page{ +%<*trace> + \@tracepush{initialise@next@page} +%</trace> +% +% \end{macrocode} +% +% \begin{macrocode} + \initialise@column@data +% \end{macrocode} +% +% \begin{macrocode} + \initialise@areas +% \end{macrocode} +% +% \begin{macrocode} + \global\page@float@count\z@ +% \end{macrocode} +% +% \begin{macrocode} + \initialise@flush@data +% \end{macrocode} +% +% \begin{macrocode} + \initialise@here@data +% \end{macrocode} +% +% \begin{macrocode} + \initialise@footins@action +% \end{macrocode} +% +% Nothing is closed when we are at the start of a page. +% \begin{macrocode} + \global\let\this@page@closed\@empty +% \end{macrocode} +% +% \begin{macrocode} + \let\@elt\initialise@float@class + \float@classes@list + \let\@elt\relax +% +%\showfloatlists +%\show\area@ddd\show\@activelist +% for safety + \global\let\this@float@box\@undefined +%<*trace> + \@tracepop{initialise@next@page} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\handle@case@of@forced@pagebreak} +% This is related to |\handle@case@of@premature@ending| but we have +% to return the penalty only if we haven't reached the last column. +% If we don't do this we would start collecting material in the +% middle of final page generation! +% \begin{macrocode} +\def \handle@case@of@forced@pagebreak{ + \ifnum\curr@col@count<\col@count + \ifnum\outputpenalty=-\@M + \@emptycol + \fi + \fi + + \ifnum\outputpenalty=-\output@balance@penalty +%<*trace> + \tr@ce{BALANCE:~ end~ point~ seen~ again} +%</trace> + \remove@guard@box@from@cclv + \ifnum\curr@col@count<\col@count + \@emptycol + \fi + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% \newpage +% +% \subsection{Cleanup Output Routine} +% +% \begin{description} +% \item[Entry:] |\setup@cleanup@or| +% \item[Exit:] |\float@placement@loop| +% \item[Prereq:] +% \item[Description:] +% Responsible for discarding unused text still on Main Vertical +% List After the end of a trial. It eats everything until it sees +% the special penalty marking the end of the last collection output +% routine. This output routine may need to be called several times +% in succession due to forced penalties in the galley. +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \setup@cleanup@or +% | +% V +% New OR: \cleanup@or +% | +% V +% <special outputpenalty reached?> --> \float@placement@loop +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% +% \begin{macro}{\setup@cleanup@or} +% \begin{macrocode} +\def\setup@cleanup@or{ + \global\vsize\maxdimen + \global\output{\cleanup@or} + } +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\cleanup@or} +% In the actual output routine we grab text and throw it away until +% we see the special output penalty. Then we prepare for the trials +% to place the floats properly. +% \begin{macrocode} +\def\cleanup@or{ +%<*trace> + \@tracepush{cleanup@or} + \tr@ce{output~pen:~ \the\outputpenalty} +%</trace> +% \end{macrocode} +% Throw everything away \ldots +% \begin{macrocode} + \global\setbox\@cclv\box\voidb@x + \global\setbox\footins\box\voidb@x +% \end{macrocode} +% \ldots\ until we see the special output penalty again. +% \begin{macrocode} + \ifnum\outputpenalty=-\output@collect@penalty + \float@placement@loop + \fi +%<*trace> + \@tracepop{cleanup@or} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \newpage +% +% \subsection{Making float pages} +% +% +% \begin{description} +% \item[Entry:] |\try@float@pages| +% \item[Exit:] --- (this happens within the OR)\\ +% On exit |\area@ddd| will be empty and the floats not being put +% onto float pages are moved to |\@activelist| (those that have +% their call outs on previous pages) and |\@mvllist| (those that +% have their call outs still on the MVL). +% \item[Prereq:] |\area@ddd| contains the float to work on; all other +% areas are empty. +% \item[Description:] +% \item[Flow:] +%\begin{footnotesize} +%\begin{verbatim} +% \try@float@pages +% | +% V +% <\area@ddd has floats?> +% | | +% ----no yes +% | | +% | V +% | (split \area@ddd into \@activelist and \@mvllist; +% | setup trial conditions) +% | | +% | V +% | \try@float@page <------------- +% | | | +% | <float page produced?> | +% | | | | +% | no yes | +% | | | | +% | | (output page) | +% | | | | +% | | (move new \area@ddd | +% | | to \@activelist) | +% | | | | +% | | ------------------ +% | | +% | | +% | (restore float conditions before last trial) +% | | +% | (restore trial condition to normal) +% | | +% ------------->| +% | +% V +%\end{verbatim} +%\end{footnotesize} +% \end{description} +% +% +% +% \begin{macro}{\try@float@pages} +% +% \begin{macrocode} +\def\try@float@pages { +%<*trace> + \@tracepush{try@float@pages} +%</trace> + \ifx\area@ddd\@empty +%<*trace> + \tr@ce{no~ deferred~ floats} +%</trace> + \else + \global\let\@activelist@empty@action\relax + \global\let\pretests@success@action\floatpage@pretests@success@action +% \end{macrocode} +% this is only a tmp: we just use |\relaxed@try@this@area| but of +% course there should be different rules for float pages (and +% different float areas and \ldots) +% \begin{macrocode} + \global\let\try@this@area\relaxed@try@this@area +% \end{macrocode} +% +% First thing to do is to split the list of deferred floats into +% those that have ther callouts already typeset (on previous pages) +% and those that we have only seen because we looked a bit +% ahead. For making float pages we can only use the former. +% \begin{macrocode} + \let\@elt\split@defer@list + \area@ddd + \let\@elt\relax + \global\let\area@ddd\@empty +% \end{macrocode} +% Now we loop until we fail to make float pages. The actual work is +% done in the macro |\try@float@page|. +% \begin{macrocode} + \@floatpagetrue + \loop + \if@floatpage + \begingroup % no nesting of \loop without grouping ... +% \end{macrocode} +% Next line prevents adding the caption to the float box. Of course +% the float page does come out even worse this way, but we don't +% get multiple captions if float page generation +% fails.\footnote{FIX by redesigning caption handling!} +% \begin{macrocode} +%<*obsolete> + \let\add@caption@to@float@box\relax %tmp!! +%</obsolete> +% \end{macrocode} +% +% A bit statistics: how many floats do we have on the +% |\@activelist|? +% \begin{macrocode} +%<*progress> + \def\@elt{\global\advance\trial@count\@ne\@gobble} + \@activelist + \let\@elt\relax + \progress@nl{} + \progress@separator + \progress@nl{STATS:~ floats~ waiting~ =~ \the\trial@count + \space on~ page~ \the\absolute@page@number\space (float~ page)} + \progress@separator + \global\trial@count\z@ +%</progress> +% \end{macrocode} +% \begin{macrocode} + \try@float@page + \endgroup + \repeat +% \end{macrocode} +% Once we are finished we have to return to normal trial +% conditions, so\ldots +% \begin{macrocode} + \global\let\try@this@area\std@try@this@area + \fi +%<*trace> + \@tracepop{try@float@pages} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\try@float@page} +% This macro tries to build a single float page from the floats in +% |\@activelist|. If it fails it (tries to) restores the state of +% the floats. If it succeeds it will output a float page and returns. +% \begin{macrocode} +\def\try@float@page { +%<*trace> + \@tracepush{try@float@page} +%</trace> +% \end{macrocode} +% Save the current state in case of failure then run the float +% placement loop (setup for this loop should have happened +% earlier). +% \begin{macrocode} + \save@current@float@state + \trial@inner@loop +% +%\typeout{float.list.after.trial} +%\showfloatlists +% +% \end{macrocode} +% Loop through all ``text columns'' and add up their heights. This +% is again only done to have some sort of measure for float pages +% and should be removed once some real code gets into this part. +% \begin{macrocode} + \dimen@\z@ + \forall@columns{ +%<*trace> + \tr@ce{\ht\the\curr@col@count=\the \csname + col@ht@ \the\curr@col@count \endcsname} +%</trace> + \advance\dimen@ \csname + col@ht@ \the\curr@col@count \endcsname + } +% \end{macrocode} +% +% If the sum of all white space is more than 300pt :-) +% \begin{macrocode} + \ifdim \dimen@ > 300pt \relax +% \end{macrocode} +% we fail +% \begin{macrocode} + \@floatpagefalse +%<*trace> + \tr@ce{float~page~failed} +%</trace> +%<*progress> + \progress@failed{no~ float~ page~ made} + \progress@nl{} +%</progress> +% \end{macrocode} +% Return to the previous state (and as can be seen by using +% |\initialise@next@page|) this needs some work; the latter might +% in fact do too much like calling +% |\initialise@flush@num|!\footnote{FIX} +% \begin{macrocode} + \saved@float@state +% \end{macrocode} +% To avoid having |\initialise@flush@num| do anything harmful we +% set |\trial@flush@seen@num| to zero at this point.\footnote{This +% needs fixing properly!} And the same is necessary for +% |\initialise@here@num|. +% \begin{macrocode} + \gdef\trial@flush@seen@num{0} + \gdef\trial@here@seen@num{0} + \initialise@next@page + \else +% \end{macrocode} +% Otherwise we claim we have a good float page. +% \begin{macrocode} +%<*trace> + \tr@ce{float~page~succeeded} + \tr@ce{We~ better~ output~ something~ now~ ...} +%</trace> +%<*progress> + \progress@nl{succeeded} + \progress@nl{} +%</progress> +% \end{macrocode} +% producing this page is rubbish as well but it can't be written +% before we have parameters and rules for making float pages. +% \begin{macrocode} + \forall@columns{ + \global\setbox\csname col@box@\the\curr@col@count\endcsname + \vbox to \csname col@ht@ \the\curr@col@count\endcsname{} + \produce@final@column + } + \perhaps@write@placements@to@fpl@file + \produce@final@page + \initialise@next@page +% \end{macrocode} +% But the final lines are for real: if we did succeed we need to +% provide a new |\@activelist| for the next potential float page. +% It should be the floats we deferred while trying to make the +% current float page followed by the floats that are still on the +% active list (i.e., those we haven't even tried for the current +% page). +% \begin{macrocode} + \xdef\@activelist{\area@ddd\@activelist} + \global\let\area@ddd\@empty + \fi +% +%\typeout{float.list.after.shipout.float.page.or.fail} +%\showfloatlists +% +%<*trace> + \@tracepop{try@float@page} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\if@floatpage} +% \begin{macro}{\@floatpagefalse} +% \begin{macro}{\@floatpagetrue} +% Switch which is set to true while we are in the process of making +% float pages and haven't failed. +% \begin{macrocode} +\newif\if@floatpage +\def\@floatpagefalse{\global\let\if@floatpage\iffalse} +\def\@floatpagetrue{\global\let\if@floatpage\iftrue} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\save@current@float@state} +% +% Save the current state of affairs concerning +% floats\footnote{Needs more work, there are now other data +% structures that should be saved if this is every going to be of +% much use. (its current usage actually could be achieved with +% simpler means). FIX or fold!}. In case of failure return to +% this state by executing |\saved@float@state|. +% \begin{macrocode} +\def\save@current@float@state { +%<*trace> + \@tracepush{save@current@float@state} +%</trace> + \xdef\saved@float@state{\gdef\noexpand\@activelist{\@activelist}} + \forall@columns { + \expandafter + \g@addto@macro + \expandafter \saved@float@state + \expandafter { \expandafter \global + \csname col@ht@ \the\curr@col@count\expandafter\endcsname + \the \csname col@ht@ \the\curr@col@count\endcsname +% \end{macrocode} +% No final |\relax| needed since this is followed by area data. And +% if there are no areas we wouldn't call this code, would we? +% \begin{macrocode} + } + } +% \end{macrocode} +% Save current state of all used float areas by looping though them. +% \begin{macrocode} + \expandafter\save@area@info\used@areas ddd\relax\relax\relax +%<*trace> + \tr@ce{saved:~ \meaning\saved@float@state} + \@tracepop{save@current@float@state} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\save@area@info} +% Save information about area and recourse. +% \begin{macrocode} +\def\save@area@info#1#2#3{ + \ifx#1\relax + \else + \edef\@tempa { + \global\csname #1#2#3@float@count\endcsname + \the\csname #1#2#3@float@count\endcsname +% \end{macrocode} +% No |\relax| needed since followed by a |\gdef|. +% \begin{macrocode} + \gdef \expandafter\noexpand \csname area@#1#2#3\endcsname + {\csname area@#1#2#3\endcsname} + } + \expandafter + \g@addto@macro + \expandafter \saved@float@state + \expandafter { \@tempa } + + \expandafter\save@area@info + \fi} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\saved@float@state} +% To return to the saved float state execute |\saved@float@state|. +% \begin{macrocode} +\let\saved@float@state\@empty +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\split@defer@list} +% +% Split |\area@ddd| list, moving those floats whose callouts have +% been typeset to |\@activelist| for consideration for (one day) +% float pages, and for allocating to text page float areas. +% +% Floats whose callouts are still on MVL are placed on |\@mvllist|. +% \begin{macrocode} +\def\split@defer@list #1 { + \def\@currbox{#1} + \expandafter\extract@this@float@actual@structure\the\toks #1 +%<*trace> + \tr@ce { #1:~\LastMark{\this@class}~ ???~\this@sequence@number } +%</trace> + \ifnum 0\LastMark{\this@class} < \this@sequence@number +%<*trace> + \tr@ce {#1:~ not~ really~ defered } +%</trace> + \@cons \@mvllist #1 + \else +%<*trace> + \tr@ce {#1:~ callout~ has~ been~ typeset} +%</trace> + \@cons \@activelist #1 + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \subsection{Preassign deferred floats} +% +% +% +% \begin{macro}{\place@deferred@floats} +% +% The |\place@deferred@floats| is supposed to distribute from +% previous pages (i.e., from the top of |\area@ddd| or more exactly +% those currently on the |\@activelist| since the |\area@ddd| was +% already split when trying to build float pages) into the areas +% of the page to be build. After all we know that for those floats +% the call outs are on previous pages so testing for them +% is unnecessary and we could save time by bypassing this stuff. +% +% On the other hand if we have flush points in the upcoming text +% all our placements might be wrong, so perhaps this doesn't really +% save so much time after all and the extra complication might not +% be worth the effort. +% +% Perhaps a compromise is to make a first column grab without any +% floats to see if we end up with a flush point (not implemented). +% +% So if we don't do this then the only thing we need to do at this +% point is to move the floats from the |\@mvllist| to the end of +% the |\@activelist|. +% \begin{macrocode} +\def\place@deferred@floats { +%<*trace> + \@tracepush{place@deferred@floats} +%</trace> + \xdef\@activelist{\@activelist\@mvllist} + \global\let\@mvllist\@empty +%\showfloatlists +%<*trace> + \@tracepop{place@deferred@floats} +%</trace> +} +% \end{macrocode} +% +% +% Here is an alternate definition which does the preassigning but +% it would need to be extended by checking for flush points or by a +% flag that ensures that if we later encounter a flush point that +% we know we could backtrack if necessary (e.g., the preassignment +% might have already deferred some floats past the flush +% point).\footnote{Extend, fix, or get rid of.} +% \begin{macrocode} +\iffalse % we don't do it right now +\def\place@deferred@floats { +%<*trace> + \@tracepush{place@deferred@floats} +%</trace> +%\showfloatlists +% \let\@elt\split@defer@list +% \area@ddd +% \let\@elt\relax +% \global\let\area@ddd\@empty + \global\let\@activelist@empty@action\relax + \global\let\pretests@success@action\floatpage@pretests@success@action +\showfloatlists + \trial@inner@loop + \xdef\@activelist{\area@ddd\@mvllist} + \global\let\area@ddd\@empty + \global\let\@mvllist\@empty +%\showfloatlists +%<*trace> + \@tracepop{place@deferred@floats} +%</trace> +} +\fi +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\floatpage@pretests@success@action} +% Version of |\pretests@success@action| for use in initial phase +% when previously deferred floats are being allocated to float areas. +% \begin{macrocode} +\def\floatpage@pretests@success@action{ +%<*trace> + \@tracepush{floatpage@pretests@success@action} +%</trace> + \update@best@trial + \trial@inner@loop +%<*trace> + \@tracepop{floatpage@pretests@success@action} +%</trace> + } +% \end{macrocode} +% \end{macro} +% +% +% +% \newpage +% +% \subsection{Support for Balancing} +% +% Code in this section (and related code in other sections) is not +% used at the moment and will most likely be replaced with something +% completely different. +% +% \begin{macro}{\if@balance} +% |@balance| is set to true if we encounter a balance penalty +% during collection. +% \begin{macrocode} +\newif\if@balance +\def\@balancefalse{\global\let\if@balance\iffalse} +\def\@balancetrue{\global\let\if@balance\iftrue} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\balancecolumns} +% +% \begin{macrocode} +\def\balancecolumns { + \add@badly@guarded@penalty\output@balance@penalty +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \newpage +% +% \subsection{Support for Flush Points} +% +% +% \begin{macro}{\if@flushseen} +% \begin{macro}{\if@flushfail} +% +% |@flushseen| is set to true if we encounter a flush penalty +% during collection. +% +% |@flushfail| is set to true if we fail a trial due to placing the +% float after the flush penalty. +% \begin{macrocode} +\newif\if@flushseen +\def\@flushseenfalse{\global\let\if@flushseen\iffalse} +\def\@flushseentrue{\global\let\if@flushseen\iftrue} +\newif\if@flushfail +\def\@flushfailfalse{\global\let\if@flushfail\iffalse} +\def\@flushfailtrue{\global\let\if@flushfail\iftrue} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\flushfloats} +% +% Possible variants: +% +% Flush only one (some) types. +% +% Fuzzyflush or, more precisely, flush-to-this-column +% or -page or -spread.\footnote{Right now "spread" is not implemented.} +% +% Parts of the flushpenalty (all types) data structure: +% +% |\flush@min@col@|\meta{num} +% |\saved@flush@min@col@|\meta{num} +% |\flush@prev@float@num@|\meta{num}\footnote{what is this Chris?} +% +% |\flush@seq@num| is the number of these so that +% \meta{num} has range [1, |\flush@seq@num|] +% +% In addition, whilst doing an fp trial we need |\trial@flush@seen@num| +% to record that we have, in this trial so far, seen the +% flush points [1, |\trial@flush@seen@num|]. +% +% +% \begin{macrocode} +\DeclareDocumentCommand\flushfloats { o O{strict} } + { \flush@floats {#1} {#2} } +% \end{macrocode} +% +% \begin{macrocode} +\def\flush@floats #1 #2 { + \add@badly@guarded@penalty\output@flush@float@penalty +% \end{macrocode} +% +% \begin{macrocode} + \gincrement@num\flush@seq@num +% \end{macrocode} +% +% \begin{macrocode} + \global\@namedef{flush@min@col@\flush@seq@num}{1} +% \end{macrocode} +% +% \begin{macrocode} + \expandafter\xdef + \csname flush@last@float@\flush@seq@num \endcsname + {\the\float@sequence@count} +% \end{macrocode} +% If |#1| is |\NoValue| the current flush point affects all float +% sequence classes, thus we store in +% |\flush@classes@list@|\meta{num} a list of all float sequence +% classes separated by semicolons. Otherwise we assume that we got +% a single float type(!) as argument and flush the corresponding +% class. +% \begin{macrocode} + \IfNoValueTF{#1}{ + \def\@elt##1{##1;} + \expandafter\xdef + \csname flush@classes@list@\flush@seq@num \endcsname + {\float@classes@list} + \let\@elt\relax + } + {\expandafter\ifx\csname sequence@class@#1\endcsname + \relax + \ErrorArgumentNotAFloatType + \else + \global\expandafter\let + \csname flush@classes@list@\flush@seq@num + \expandafter\endcsname + \csname sequence@class@#1\endcsname + \fi + } +% \end{macrocode} +% The argument |#2| holds the fuzziness of the flush point which +% currently can be either |strict|, |column| or |page|. +% We link |\flush@fuzziness@|\meta{num} to the code stored in +% |\flushcheck@#2| after making sure that such code +% exists.\footnote{Improve error handling (as elsewhere)} +% \begin{macrocode} + \@ifundefined {flushcheck@#2} + \userinputERROR + {\global\expandafter\let + \csname flush@fuzziness@\flush@seq@num \expandafter \endcsname + \csname flushcheck@#2\endcsname +%<*trace> + \tr@ce{flush@fuzziness@\flush@seq@num \space + =:~ \expandafter\noexpand\csname flushcheck@#2\endcsname + } +%</trace> + } +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\clearpage} +% \LaTeX's |\clearpage| command now looks like this: +% \begin{macrocode} +\def\clearpage{ \flushfloats \newpage } +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\doubleclearpage} +% \LaTeX's |\doubleclearpage| command also needs a new +% definition:\footnote{But not this one :-) FIX!} +% \begin{macrocode} +\def\doubleclearpage{ \clearpage } +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\flush@seq@num} +% The number |\flush@seq@num| records the number of flush +% points we have have seen during collection. +% \begin{macrocode} +\def\flush@seq@num{0} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\trial@flush@seen@num} +% The number |\trial@flush@seen@num| records the number of flush +% points we have seen so far during a trial, i.e., it will be +% initialised to zero at the beginning of the trial and advanced by +% one for each flush point encountered. +% \begin{macrocode} +\def\trial@flush@seen@num{0} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\flush@last@float@xxx} +% \begin{macro}{\flush@min@col@xxx} +% \begin{macro}{\flush@classes@list@xxx} +% \begin{macro}{\flush@fuzziness@xxx} +% +% For each flush point we have a data structure in which we store +% relevant information. This data structure is provided by a set of +% macros which can be accessed by using the number of the current +% flush point and constructing |\csname|s from it, e.g., to get at +% the ``flush min col'' for the flush point with number 3 would be +% |\csname flush@min@col@3\endcsname|. + +% |\flush@min@col@|\meta{num} holds the column number in which we +% last seen the flush penalty while trying to find a solution for +% the current page. This is initialised to 1 in collection@or when +% a flush penalty is encountered during collection (since 1 is the +% earliest column in which the flush penalty finally may fall). By +% adding additional floats to the page the penalty might move to a +% later column but normally not back to an earlier +% one\footnote{There is a possibility that this happens if there is +% enough space vanishing at the new break.} If we end up with the +% flush penalty moving backwards we force a break at this point +% until we reach the column where it was before. The reason for +% this action is that we might have allocated floats to later +% columns that would otherwise end after after the flush penalty. +% +% If by adding floats to the trials the flush penalty is moved to +% the next page we set |\flush@min@col@|\meta{num} to +% |\maxdimen|. The actual test to see if a flush penalty still +% belongs to the current page is to check against |\curr@col@count| +% (so |\curr@col@count+1| would be sufficient, but using +% |\maxdimen| avoids calculations. +% +% |\flush@classes@list@|\meta{num} holds a list of float types which +% are affected by the current flush point. +% +% |\flush@fuzziness@|\meta{num} holds the fuzziness associated with +% the flushpoint, valid values are |strict| and |page|. +% +% By defining (some of) them on top-level we avoid unnecessary +% entries on the savestack since they would otherwise be +% constructed (locally) first within the output routine (when doing +% |\ifx| testing), resulting in |\relax| being stored on the +% savestack. +% \begin{macrocode} +\expandafter\let\csname flush@last@float@1 \endcsname\ERROR +\expandafter\let\csname flush@classes@list@1 \endcsname\ERROR +\expandafter\let\csname flush@min@col@1 \endcsname\ERROR +\expandafter\let\csname flush@fuzziness@1 \endcsname\ERROR +\expandafter\let\csname flush@last@float@2 \endcsname\ERROR +\expandafter\let\csname flush@classes@list@2 \endcsname\ERROR +\expandafter\let\csname flush@min@col@2 \endcsname\ERROR +\expandafter\let\csname flush@fuzziness@2 \endcsname\ERROR +\expandafter\let\csname flush@last@float@3 \endcsname\ERROR +\expandafter\let\csname flush@classes@list@3 \endcsname\ERROR +\expandafter\let\csname flush@min@col@3 \endcsname\ERROR +\expandafter\let\csname flush@fuzziness@3 \endcsname\ERROR +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\flush@classes@list@max} +% |\flush@classes@list@max| holds the concatenation of all +% |\flush@classes@list@|\meta{num} on the page currently +% constructed. This information is needed in case we get to a new +% float and the preliminary tests suggests that it needs to be +% deferred. In that case we need to know which flush points have +% been seen previously to decide whether or not we can defer the +% new float. +% \begin{macrocode} +\let\flush@classes@list@max\@empty +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\initialise@flush@data} +% \begin{macrocode} +\def \initialise@flush@data{ +%<*trace> + \@tracepush{initialise@flush@data} +%</trace> +% \end{macrocode} +% Does this need any documentation? +% +% Well, we have to get rid of all information relating to flush +% float penalties that have been typeset on the previous page and +% move the remaining ones (if any) to the front. +% \begin{macrocode} + \count@\flush@seq@num\relax + \advance\count@ -\trial@flush@seen@num +%<*trace> + \tr@ce{flush@seq@num~ + =~ \flush@seq@num\space <-~ + \the\count@ } +%</trace> +% \end{macrocode} +% Something wrong here if we get negative values! +% \begin{macrocode} +%<*debug> + \ifnum\count@<\z@ \ERROR \fi +%</debug> +% \end{macrocode} +% +% \begin{macrocode} + \xdef\flush@seq@num{\the\count@} +% \end{macrocode} +% +% \begin{macrocode} + \@tempcnta\trial@flush@seen@num + \@tempcntb\z@ + \loop + \ifnum \@tempcntb < \count@ + + \advance\@tempcnta\@ne + \advance\@tempcntb\@ne +%<*trace> + \tr@ce{flush@fuzziness@\the\@tempcntb\space + =~ \expandafter \noexpand + \csname flush@fuzziness@\the\@tempcntb\endcsname\space + <-~ \expandafter \noexpand + \csname flush@fuzziness@\the\@tempcnta \endcsname + } + \tr@ce{flush@last@float@\the\@tempcntb\space + =~ \csname flush@last@float@\the\@tempcntb\endcsname\space <-~ + \csname flush@last@float@\the\@tempcnta \endcsname + } + \tr@ce{flush@classes@list@\the\@tempcntb\space + =~ \csname flush@classes@list@\the\@tempcntb\endcsname\space <-~ + \csname flush@classes@list@\the\@tempcnta \endcsname + } + \tr@ce{flush@min@col@\the\@tempcntb\space <-~ 1} +%</trace> + \global\expandafter\let + \csname flush@fuzziness@\the\@tempcntb \expandafter\endcsname + \csname flush@fuzziness@\the\@tempcnta \endcsname + + \global\expandafter\let + \csname flush@last@float@\the\@tempcntb \expandafter\endcsname + \csname flush@last@float@\the\@tempcnta \endcsname + + \global\expandafter\let + \csname flush@classes@list@\the\@tempcntb \expandafter\endcsname + \csname flush@classes@list@\the\@tempcnta \endcsname + + \global\@namedef{flush@min@col@\the\@tempcntb}{1} + \repeat +% \end{macrocode} +% +% \begin{macrocode} + \global\let\flush@classes@list@max\@empty +% \end{macrocode} +% Need to reset |\trial@flush@seen@num| in case the current macro +% is called again too early, e.g., if it is called to initialize a +% float page and then again to initialize a text page. +% \begin{macrocode} + \gdef\trial@flush@seen@num{0} +%<*trace> + \@tracepop{initialise@flush@data} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \subsection{Support for Here Points} +% +% A ``Here Point'' is a place in the galley at which something is +% supposed to happen. For example, a marginal note needs to be +% attached to the column, or a float needs to be inserted into the +% column (here float), or it needs to be made sure that from that +% point on there is still a certain amount of space available in the +% column. +% +% With each here point there is associated a float structure (i.e. a +% box and its corresponding |\toks| register) although in most cases +% only parts of that structure is used. In addition each here point +% has an associated dimension which denotes the amount of available +% space which is required after the here point in the column to allow +% to place the here point into this column. If this requirement is not +% met the here point is moved to the next column (or page) by ending +% the current column prematurely at the last legal breakpoint before +% the here point (not at the here point itself\footnote{It should be +% considered to allow breaking directly at the here point in special +% cases, i.e., specified at the here point declaration.}). This +% behaviour will ensure that a line of text preceding the here point +% will also be moved to the next column or page which is important in +% case of marginals and similar situations. In case of here floats it +% might not be a requirements so perhaps this should be made +% customisable. +% +% At the moment the ``type'' in the float structure is used to define +% the type of here point. E.g., +% \begin{description} +% \item[mpar] denotes a marginal +% \item[rspace] denotes a requested space +% \item[figure,table,\ldots] all normal float types identify the here +% point as belonging to a here float. +% \end{description} +% The down side of this approach is that ``mpar'' can't be used as a +% float type any longer and the whole approach might be too difficult +% to extend this way. This needs certainly needs a cleanup. +% +% It is quite likely that there will be additional values that need +% storing on a per here point basis. For this reason the code below +% provides the requiredspace as a data structure external to the float +% structure. Otherwise it could probably be integrated therein. +% +% When a here point is encountered while making columns for a trial or +% for the final page, its requirements are checked. If they are +% fulfilled then a here-point-type specific function will update the +% column material (e.g. by adding a here float or a marginal). +% +% Here points are in many aspects like flush points. So most of the +% code below should not be very surprising. +% +% \begin{macro}{\here@seq@num} +% The number |\here@seq@num| records the number of here +% points we have have seen during collection. +% \begin{macrocode} +\def\here@seq@num{0} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\trial@here@seen@num} +% The number |\trial@here@seen@num| records the number of here +% points we have seen so far during a trial, i.e., it will be +% initialised to zero at the beginning of the trial and advanced by +% one for each here point encountered. +% \begin{macrocode} +\def\trial@here@seen@num{0} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@herelist} +% |\@elt| list of floats that should appear at a here point. +% \begin{macrocode} +\let\@herelist\@empty +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\saved@herelist} +% Saved version of the |\@herelist| while we run a through the +% float placement trial since we need the full |\@herelist| again in +% the next trial. +% \begin{macrocode} +\let\saved@herelist\@empty +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\here@point} +% |\here@point| adds a here point to the MVL. It takes two +% arguments: the box reference associated with the here point and +% the vertical space that needs to be reserved for the material +% added. +% \begin{macrocode} +\def\here@point #1#2{ +% \end{macrocode} +% +% \begin{macrocode} + \@cons\@herelist#1 +% \end{macrocode} +% +% \begin{macrocode} + \gincrement@num\here@seq@num +% \end{macrocode} +% +% \begin{macrocode} + \global\@namedef{here@min@col@\here@seq@num}{1} +% \end{macrocode} +% +% \begin{macrocode} + \setlength\dimen@{#2} + \expandafter\xdef + \csname here@required@space@\here@seq@num \endcsname + {\the\dimen@} +% \end{macrocode} +% +% \begin{macrocode} + \add@badly@guarded@penalty\output@here@float@penalty +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\initialise@here@data} +% \begin{macrocode} +\def \initialise@here@data{ +%<*trace> + \@tracepush{initialise@here@data} +%</trace> +% Does this need any documentation? +% +% Well, we have to get rid of all information relating to here +% float penalties that have been typeset on the previous page and +% move the remaining ones (if any) to the front. +% \begin{macrocode} + \count@\here@seq@num\relax + \advance\count@ -\trial@here@seen@num +%<*trace> + \tr@ce{here@seq@num~ + =~ \here@seq@num\space <-~ + \the\count@ } +%</trace> +% \end{macrocode} +% Something wrong hereif we get negative values! +% \begin{macrocode} +%<*debug> + \ifnum\count@<\z@ \ERROR \fi +%</debug> +% \end{macrocode} +% +% \begin{macrocode} + \xdef\here@seq@num{\the\count@} +% \end{macrocode} +% +% \begin{macrocode} + \@tempcnta\trial@here@seen@num + \@tempcntb\z@ + \loop + \ifnum \@tempcntb < \count@ + + \advance\@tempcnta\@ne + \advance\@tempcntb\@ne +%<*trace> + \tr@ce{here@required@space@\the\@tempcntb\space + =~ \csname here@required@space@\the\@tempcntb\endcsname\space <-~ + \csname here@required@space@\the\@tempcnta \endcsname + } + \tr@ce{here@min@col@\the\@tempcntb\space <-~ 1} +%</trace> + \global\expandafter\let + \csname here@required@space@\the\@tempcntb \expandafter\endcsname + \csname here@required@space@\the\@tempcnta \endcsname + + \global\@namedef{here@min@col@\the\@tempcntb}{1} + \repeat +%<*trace> + \@tracepop{initialise@here@data} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\split@off@last@line} +% +% When a here point doesn't fit onto the current page or column for +% some reason it will be moved into the next column. In some cases, +% e.g., when the here point is associated with the line before it +% (as, for example, in marginals) it is necessary to move the line +% also to the later column. +% +% The purpose of |\split@off@last@line| (to be called inside the +% OR) is to split box 255 at the latest possible breakpoint before +% the end and return the material following this breakpoint to the +% MVL. +% +% The idea is as follows: if we subtract 1sp from the height of +% box 255 and also subtract all of its internal shrinkability and +% then split it to this height it can't any longer reach the final +% breakpoint (by 1sp). Thus it will settle with some earlier +% breakpoint and chances are very very good that this will be the +% prefinal one. +% \begin{macrocode} +\def \split@off@last@line{ +%<*trace> + \@tracepush{split@off@last@line} + \tr@ce{goal:~ \the\pagegoal;~ total:~ \the\pagetotal;~ shrink:~ + \the\pageshrink} + \tr@ce{ht255:~ \the\ht255;~ dp255:~ \the\dp255} +%</trace> +% \end{macrocode} +% +% +% \begin{macrocode} + \dimen@\ht\@cclv +% \end{macrocode} +% Looking at |\ht255| should be the same as |\pagetotal-\pagedepth| +% or not?\footnote{Doesn't seem to be the case, bug in the code, +% the program, or in my thinking? (seems to be a bug in \TeX: +% pagedepth is always zero in the OR!)} +% \begin{macrocode} + \advance\dimen@-\pageshrink + \advance\dimen@-1sp +%{\showoutput\showbox\@cclv} +% \end{macrocode} +% Before splitting we have to ensure that the maximum depth is not +% larger than the maximum depth allowed on the MVL. +% \begin{macrocode} + \splitmaxdepth\@maxdepth + \setbox\z@\vsplit\@cclv to\dimen@ +%{\showoutput\showbox\z@} +%{\showoutput\showbox\@cclv} +% \end{macrocode} +% +% Before we now |\unvbox| 255 back onto the MVL we have to make sure +% that the sum of its vertical dimensions plus the requested space +% for the current here point is smaller than a full column height. +% +% If we don't do that we might end up with a situation where we are +% pushing the two from column to columns since they will never fit. +% \begin{macrocode} + \dimen@\csname + here@required@space@\trial@here@seen@num + \endcsname + \advance\dimen@\ht\@cclv + \advance\dimen@\dp\@cclv +% \end{macrocode} +% If the sum is too large we reduce the required space for the here +% point and complain (not really done yet the latter). +% \begin{macrocode} + \ifdim \dimen@ > \textheight + \ERROR-HERE-TOO-LARGE + \dimen@\textheight + \advance\dimen@-\ht\@cclv + \advance\dimen@-\dp\@cclv + \expandafter\xdef\csname + here@required@space@\trial@here@seen@num + \endcsname{\the\dimen@} + \fi +% \end{macrocode} +% So now we can |\unvbox| and then move the top from the split back +% into 255 (essentially to have it taken out of that register by +% the code following, but such is life). +% \begin{macrocode} + \unvbox\@cclv + \global\setbox\@cclv\box\z@ +%<*trace> + \@tracepop{split@off@last@line} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Support for Grid Points} +% +% +% +% +% \begin{macro}{\align@collected@galley@and@restart} +% |\align@collected@galley@and@restart| is called inside +% |\some@column@or| when we have encountered a grid point. It is +% supposed to align the current line with the text grid and then +% restarts the galley processing. +% +% We do this by putting the material gathered so far into a box of +% appropriate size, and then push this pack onto the recent +% contributions for reconsideration. +% \begin{macrocode} +\def \align@collected@galley@and@restart { +%<*trace> + \@tracepush{align@collected@galley@and@restart} + \tr@ce{GRID:~ page~ goal~\space\space\space =~ \the\pagegoal} + \tr@ce{GRID:~ page~ total~\space\space =~ \the\pagetotal} + \tr@ce{GRID:~ page~ depth~\space\space =~ \the\pagedepth} + \tr@ce{GRID:~ page~ shrink~\space =~ \the\pageshrink} + \tr@ce{GRID:~ page~ stretch~ =~ \the\pagestretch} + \tr@ce{GRID:~ page~ fil~ stretch~ =~ \the\pagefilstretch} + \tr@ce{GRID:~ page~ fill~ stretch~ =~ \the\pagefillstretch} + \tr@ce{GRID:~ page~ filll~ stretch~ =~ \the\pagefillstretch} + \tr@ce{GRID:~ ht~ 255~\space =~ \the\ht\@cclv} + \tr@ce{GRID:~ dp~ 255~\space =~ \the\dp\@cclv} +%</trace> +% \end{macrocode} +% As a first step we remove the guard box since it has now served +% its purpose. +% \begin{macrocode} + \remove@guard@box@from@cclv +% \end{macrocode} +% Then we calculate the distance to nearby grid points. +% \begin{macrocode} + \snap@to@grid{\ht\@cclv}\pagesetup@grid@point@sep +% \end{macrocode} +% So the next step is to make a decision which grid point to +% use. The strategy used below can probably be refined +% further\ldots +% +% First we test if the next grid point down makes us fall off the +% page\footnote{We should use \texttt{\string\pagegoal} for the +% test I think, not the commented out construct below, since in +% case of footnotes the available space for text might has be +% reduced!}, if so\ldots +% \begin{macrocode} + \ifdim \returned@size > \pagegoal + % \csname col@ht@ \the\curr@col@count\endcsname % not! +% \end{macrocode} +% \ldots we better try using the previous grid point. +% \begin{macrocode} + \ifdim \returned@lower@delta@size < \pageshrink +% \end{macrocode} +% If the |\pageshrink| allows us to reach the previous point then +% use it. +% \begin{macrocode} +% can use it: do so +%<*trace> + \tr@ce{GRID:~ outside~ page,~ choosing~ lower~ grid~ point} +%</trace> + \global\let \returned@size \returned@lower@size + \xdef \returned@delta@size {-\returned@lower@delta@size } + \else +% \end{macrocode} +% Otherwise, ouch \ldots{} what now? Can this happen? Unfortunately +% yes, it seems to happen, for example, when we are trying to place +% floats.\footnote{Analyse this situation and decide on a course of +% action if necessary.} +% \begin{macrocode} + \OuchERROR + \fi +% \end{macrocode} +% Otherwise we are in the normal case, i.e., somewhere in the +% middle of the page. +% \begin{macrocode} + \else +% \end{macrocode} +% So now we can in principle choose either grid point. The code +% below makes the decision based on which grid point is closer but +% chooses the previous point only if |\pageshink| allows +% it.\footnote{One could also have a look at the available +% stretchability and base the decision on the resulting badness, +% this might in fact be the more appropriate way!} +% \begin{macrocode} + \ifdim \returned@lower@delta@size < \returned@delta@size \relax + \ifdim \returned@lower@delta@size < \pageshrink +%<*trace> + \tr@ce{GRID:~ choosing~ lower~ grid~ point} +%</trace> + \global\let \returned@size \returned@lower@size + \xdef \returned@delta@size {-\returned@lower@delta@size } + \fi + \fi + \fi +%<*trace> + \tr@ce{GRID:~ adjustment:~ \the\ht\@cclv\space ->~ \returned@size} +%</trace> +% \end{macrocode} +% Whatever the decision was, we finally bundle up all material in a +% box with the vertical size being that of the chosen grid point +% (no |\maxdepth| setting in this case) and return this box to the +% MVL followed by any footnotes found in that process. These +% footnotes are reinserted so that they will be reconsidered but +% since we have no break point between the box and them they will +% be considered as a unit. +% \begin{macrocode} + \vbox to\returned@size{\unvbox\@cclv} + \@reinserts +% \end{macrocode} +% We know that the material returned to the MVL is followered +% immediately by a box of size zero followed by a penalty thus +% there will be a breakpoint in the right place (or so we hope) so +% that the box plus the following footnotes will still fit into the +% column when reprocessed. +% \begin{macrocode} +%<*trace> + \@tracepop{align@collected@galley@and@restart} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\OuchERROR} +% This part of the code (as far as I can see right now) will be +% executed if there is some larger display object (ie off grid) +% which will just fit onto the page unaligned but not if we align +% to the next grid point. The reason for this is that somewhere on +% the column there are also footnotes for example, which result in +% the column not being an integral number of grid lines. +% \begin{macrocode} +\def\OuchERROR{ +%<*trace> + \tr@ce{Failed:~grid~ overflowing~ column~ \the\curr@col@count} +%</trace> +%<*progress> + \progress@failed{next~ possible~ grid~ point~ in~ column~ + \the\curr@col@count\space outside~ page} +%</progress> +% \end{macrocode} +% I think essentially what is needed here is to split the column +% just before the current line, ie, using something like +% |\split@off@last@line| (except that this only works for here +% points right now) and this move the grid align penalty to the +% next column.\footnote{Not done! FIX} +% \begin{macrocode} +% \split@off@last@line +% \(re)???add@guarded@penalty\output@grid@align@penalty +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\std@AlignToGrid} +% This is the definition for |\AlignToGrid| if we are really doing +% grid based layout. +% \begin{macrocode} +\def\std@AlignToGrid{ + \add@badly@guarded@penalty\output@grid@align@penalty +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\IgnoreAlignToGrid} +% \begin{macro}{\ObeyAlignToGrid} +% |\IgnoreAlignToGrid| will turn off automatic grid alignment for a +% while, while |\ObeyAlignToGrid| will turn it on again. This is +% needed in commands that want to set something outside the grid +% and then realign afterwards, e.g., a heading. If that heading +% would follow, say, a list that issued a |\AlignToGrid| to be +% executed on the next paragraph, that |\AlignToGrid| would +% effectively appear on the heading title thus forcing that to be +% on a grid line, which is typically not intended. So the heading +% macro first says |\IgnoreAlignToGrid| then typesets the material +% which should be not aligned, then says |\ObeyAlignToGrid| and +% prepares to install its own |\AlignToGrid| (typically after the +% first line of text via |\everypar|). +% \begin{macrocode} +\def\IgnoreAlignToGrid{ + \global\let\AlignToGrid\relax +} +\def\ObeyAlignToGrid{ + \global\let\AlignToGrid\std@AlignToGrid +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% +% \begin{macro}{\AlignToGrid} +% |\AlignToGrid| is the command that inserts a grid point which +% triggers alignment to the text grid for the current line (if we +% are doing grid based design). It should be set in the page setup +% so the default is an error. +% \begin{macrocode} +\let\AlignToGrid\ERROR +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\TextAlignToGrid} +% In nearly all cases the alignment should be done for a text line, +% so we provide this abbreviation which starts horizontal mode if +% necessary. +% \begin{macrocode} +\def\TextAlignToGrid{ \leavevmode \AlignToGrid } +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \subsection{Initialisations} +% +% The initialisation at begin document isn't properly done +% yet. Some bits are done unnecessarily here (by calling +% initialisation commands that do too much and some bits are +% problably still in the wrong place. Furthermore the column data +% initialisation needs to be resolved properly. Right now we +% hardwire a maximum of 6 columns down there and initialise the +% data structures for all the potential columns independently of +% whether or not they are ever being used.\footnote{SORT OUT!} +% \begin{macrocode} +\AtBeginDocument{ + \begingroup + \col@count6\relax + \initialise@column@data +% \end{macrocode} +% More column data stuff which needs to be set only the very first +% time! +% \begin{macrocode} + \forall@columns { +% \end{macrocode} +% +% \begin{macrocode} + \def\@elt#1{ + \global\@namedef{fl@\the\curr@col@count @#1}{0} + \global\@namedef{tfl@\the\curr@col@count @#1}{0} + } + \float@classes@list +% \end{macrocode} +% Setting |\@elt| back to |\relax| is done below. +% \begin{macrocode} + } +% \end{macrocode} +% +% The default for fps should be all areas known (not only those +% currently used!) +% \begin{macrocode} + \def\@elt#1{ + \global\expandafter\let\csname fps@#1\endcsname\known@areas + \global\@namedef{fl@0@#1}{0} + } + \float@classes@list + \endgroup +% \end{macrocode} +% +% \begin{macrocode} +% \initialise@next@page +% \end{macrocode} +% Start the document by collecting text. +% \begin{macrocode} + \@collecting@new@materialtrue + \setup@collection@or +} +% \end{macrocode} +% +% +% \endinput +\endinput +% +% $Log: xo-or.dtx,v $ +% Revision 1.53 2000/08/11 07:14:25 latex3 +% added header +% +% Revision 1.52 2000/08/11 06:49:21 latex3 +% untabify +% +% Revision 1.51 2000/08/11 06:46:48 latex3 +% change logic for handling special penalties once more (and still not +% okay) +% +% Revision 1.50 2000/08/06 19:03:44 latex3 +% change initialisation at \begin{document} +% fix \columnbreak +% +% Revision 1.49 2000/08/04 13:58:16 latex3 +% documented issue when grid point overflows column +% +% Revision 1.48 2000/08/04 10:22:31 latex3 +% added \split@skip (probably not final version) +% +% Revision 1.47 2000/07/26 20:37:03 latex3 +% working version of grid points (text grids) +% +% Revision 1.46 2000/07/21 13:52:13 latex3 +% more renaming for float sequence class concept +% +% Revision 1.45 2000/07/19 17:12:08 latex3 +% introduced float sequence class concept +% added variables for float area separation +% +% Revision 1.44 2000/07/10 19:24:59 latex3 +% some start at supporting "balance points" (unfinished). +% added \initialise@column@data. +% getting rid of extra empty page at end due to old defnition of +% \clearpage. +% +% Revision 1.43 2000/07/04 19:45:40 latex3 +% fix GRID stuff (restore all values as needed) +% +% Revision 1.42 2000/07/01 16:07:26 latex3 +% use \update@this@area@columns +% integrate code to support grid design (first draft) +% +% Revision 1.41 2000/06/29 17:40:44 latex3 +% introduced \setup@this@area +% +% Revision 1.40 2000/06/26 15:16:15 latex3 +% prototype support for \pagesetup@float@area@sep +% +% Revision 1.39 2000/06/22 20:07:51 latex3 +% renamed some macros to get them more uniform +% +% Revision 1.38 2000/06/22 10:59:57 latex3 +% Included support for writing fpl files +% +% Revision 1.37 2000/06/21 09:55:41 latex3 +% fix typo +% +% Revision 1.36 2000/06/19 19:03:56 latex3 +% make \gincrement@num and \gdecrement@num behave (not update \count@) +% cleanup flushing (if fail only move flush point one column) +% +% Revision 1.35 2000/06/18 14:59:50 latex3 +% docu updates (and a bug fix due to typo) +% +% Revision 1.34 2000/06/16 11:21:14 latex3 +% rename \construct@and@test@col@height to \construct@and@test@col@ht +% rename \construct@and@test@col@heights to \construct@and@test@col@hts +% rename \cl@height1 to \@col@ht@1 (etc) +% +% Revision 1.33 2000/06/16 11:05:25 latex3 +% implemented tfl@ support (top area float sequences) +% support float-callout-span-constraint +% more documentation +% +% Revision 1.32 2000/06/15 15:20:16 latex3 +% implemented new semantics for area names +% +% Revision 1.31 2000/06/15 09:32:18 latex3 +% added mising \end{macro}'s +% +% Revision 1.30 2000/06/13 20:44:25 latex3 +% guard the output@collect@penalty +% implemented fuzzy flushing (except for spreads) +% +% Revision 1.29 2000/06/06 11:03:21 latex3 +% before attempting fuzzyflush +% +% Revision 1.28 2000/05/03 20:17:31 latex3 +% need more info about here floats +% +% Revision 1.27 2000/05/03 18:45:40 latex3 +% fix bugs: always have a trial run wihtout floats to initialise here +% and flush points; reset \trial@flush@seen@num after using it to update +% the data structures on a new pages; have adding to the defer area +% close other areas :-) +% more documentation +% +% Revision 1.26 2000/04/27 19:50:11 latex3 +% some stats gathered now +% combine \grab@column@or and \best@column@or as far as possible +% some bug fixes and additional documentation +% +% Revision 1.25 2000/04/21 19:08:43 latex3 +% code cleanup +% additional documentation +% fixes for here points +% support for footnote setup +% +% Revision 1.24 2000/04/11 21:06:06 latex3 +% basically Chris's 1.24 plus my changes +% +% Revision 1.24 2000/04/10 16:41:14 car2 +% typos, comments and guardbox removal +% +% Revision 1.23 2000/04/09 20:02:00 latex3 +% fix topskip problem in collection +% added first draft of marginpar support +% +% Revision 1.22 2000/04/08 09:47:06 latex3 +% first draft of here point implementation +% code cleanup +% further documentation +% +% Revision 1.21 2000/03/31 17:12:41 latex3 +% disable preplacing deferred floats (until caption handling is fixed) +% fix float page handling +% ensure that float pages don't add additional captions (don't mind that +% the float page comes out even worse) +% +% Revision 1.20 2000/03/26 21:05:11 latex3 +% work on float pages +% some renaming in particular \try@this@area +% and \try@next@area +% some more documentation +% +% Revision 1.19 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.18 2000/03/22 15:51:11 latex3 +% some normalisations of names +% moved code around +% lot of updates +% +% Revision 1.17 2000/03/17 20:26:40 latex3 +% more fixes to flushing (looks good now) +% +% Revision 1.16 2000/03/16 10:28:29 latex3 +% partial and full flush working for the first time +% +% Revision 1.15 2000/03/05 19:36:53 latex3 +% some renaming +% support multiple columns (6 max right now) +% fix flush float logic (hopefully) +% +% Revision 1.14 2000/02/28 23:41:14 david +% deadcycles +% +% Revision 1.13 2000/02/27 15:39:53 david +% *** empty log message *** +% +% Revision 1.12 2000/02/27 15:12:00 david +% 2nd attempt at flush floats (working as far as implemented) +% +% Revision 1.11 2000/02/27 11:26:35 david +% first attempt at flush floats +% +% Revision 1.10 2000/02/26 18:20:09 david +% added pre-allocation of deferred floats to float areas +% +% Revision 1.9 2000/02/21 23:25:11 david +% t11|t22 support in optional argument +% +% Revision 1.8 2000/02/19 23:14:58 david +% chris' doc fix +% +% Revision 1.7 2000/02/16 13:40:40 latex3 +% added 3col support +% +% Revision 1.6 2000/02/16 10:07:13 latex3 +% added further documentation +% fixed bug by removing code from \try@this@area to +% \pretests@success@action +% handle case of hitting special output penalty during trial or +% page production +% handle case of \newpage ie penalty -10000 +% +% Revision 1.5 2000/02/15 01:08:25 david +% dead code +% +% Revision 1.4 2000/02/13 22:40:13 latex3 +% moved some stuff around and added macro environments +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-page.dtx b/Master/texmf-dist/source/latex3/xor/xo-page.dtx new file mode 100644 index 00000000000..7dff99b8119 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-page.dtx @@ -0,0 +1,694 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-page.dtx,v 1.34 2000/08/11 07:14:27 latex3 Exp $ +% \end{macrocode} +% +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% +% \subsection{Footnote setup} +% +% \begin{macro}{\initialise@footins@action} +% The |\initialise@footins@action| is a hook to add code to the +% page initialisation phase related to the footnote insertions. For +% example, when all footnotes are accumulated in the last column we +% need to make footnote insertions invisible when gathering +% material for the first columns. +% \begin{macrocode} +\let\initialise@footins@action\relax +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\deal@with@footins@action} +% The |\deal@with@footins@action| hook is called in the +% |\grab@column@or| and the |best@column@or| output routine to do +% something to the accumulated footnote insertions if +% necessary. I.e., it is called for every column. +% \begin{macrocode} +\let\deal@with@footins@action\relax +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macrocode} +\DeclareTemplateType{footnotesetup}{0} +% \end{macrocode} +% +% +% +% +% \begin{macrocode} +\DeclareTemplate{footnotesetup}{std}{0}{ + text-sep =+l \skip\footins, + max-height =+l \dimen\footins, + } + { + + \global\skip\footins 10pt plus 5pt + \global\dimen\footins.7\textheight + + \DoParameterAssignments + + \let\initialise@footins@action\relax + \let\deal@with@footins@action\relax + + \global\count\footins\@m + + } +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{footnotesetup}{ftnright}{0}{ + text-sep =+l \rcol@footinsskip, + max-height =+l \dimen\footins, + } + { + + \global\rcol@footinsskip 10pt plus 5pt + \global\dimen\footins\textheight + + \DoParameterAssignments + + \let\initialise@footins@action\initialise@footins@ftnright + \let\deal@with@footins@action\deal@with@footins@ftnright + + } +% \end{macrocode} +% +% +% Setting |max-height| as done below has not the desired effect and +% needs investigation.\footnote{FIX!} +% +% \begin{macrocode} +\DeclareTemplate{footnotesetup}{margin}{0}{ + max-height =+l \dimen\footins, + } + { + + \global\dimen\footins.7\textheight + + \DoParameterAssignments + + \let\initialise@footins@action\initialise@footins@margin + \let\deal@with@footins@action\deal@with@footins@margin + +% \end{macrocode} +% If the footnote do not appear within the columns we have to +% ensure that the |\insert| does not change the page +% calculations. This needs changes in two places: +% \begin{macrocode} + \global\count\footins\z@ + \global\skip\footins \z@ + + } +% \end{macrocode} +% +% +% +% +% \subsubsection{Footnote setup ftnright} +% +% In this section we provide the code for running all footnotes in the +% last column. +% +% \begin{macro}{\saved@footins} +% +% \begin{macrocode} +\newbox\saved@footins +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\rcol@footinsskip} +% \begin{macrocode} +\newskip\rcol@footinsskip +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\initialise@footins@ftnright} +% \begin{macrocode} +\def \initialise@footins@ftnright { + \global\setbox\saved@footins\box\voidb@x + \global\skip\footins\z@ + \global\count\footins\z@ + \global\dimen\footins\textheight +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \begin{macro}{\deal@with@footins@ftnright} +% \begin{macrocode} +\def \deal@with@footins@ftnright { +%<*trace> + \@tracepush{deal@with@footins@ftnright} +%</trace> +% \end{macrocode} +% If we are not in the last column we save any footnote accumulated +% in |\footins| in a separate |\saved@footins| box. This way any +% later code that checks |\footins| for constraints will not fire +% incorrectly. +% \begin{macrocode} + \ifnum\curr@col@count<\col@count +%<*trace> + \tr@ce{not~ last~ col} +%</trace> + \ifvoid\footins + \else + \global\setbox\saved@footins + \vbox{\unvbox\saved@footins + \unvbox\footins} + \fi +% \end{macrocode} +% If we are in the second last column we have to change the +% procedure: we now have to return all saved footnotes to the MVL +% and modify the insertion register values so that from now on +% footnotes need space in the column.\footnote{Not correctly +% handled is the case that we have accumulated more than a full +% column of footnotes before!} +% \begin{macrocode} + \count@\col@count + \advance\count@\m@ne + \ifnum\curr@col@count=\count@ % cur col = second last col +%<*trace> + \tr@ce{second~ last~ col} +%</trace> + \global\count\footins\@m + \global\skip\footins\rcol@footinsskip + \ifvoid\saved@footins + \else + \insert\footins{\unvbox\saved@footins} + \fi + \fi + \fi +%<*trace> + \@tracepop{deal@with@footins@ftnright} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\deal@with@footins@margin} +% \begin{macrocode} +\def \deal@with@footins@margin { +%<*trace> + \@tracepush{deal@with@footins@margin} +%</trace> + \ifvoid\footins + \else + \global\setbox\saved@footins + \vbox{\unvbox\saved@footins + \unvbox\footins} + \fi +%<*trace> + \@tracepop{deal@with@footins@margin} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\deal@with@footins@margin} +% \begin{macrocode} +\def \initialise@footins@margin { + \global\setbox\saved@footins\box\voidb@x +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{A basic page setup template} +% +% +% \begin{macro}{\test@named@key} +% This should perhaps be made more general +% \begin{macrocode} +\def\test@named@key #1#2#3#4 { + \global\expandafter\let \expandafter #1 + \csname #2 \endcsname + \ifx #1 \relax + \PackageError{template}{#3~ unknown} + {#3~ can~ be~ either~ #4} + \fi +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\DeclareFloatArea} +% We declare new float areas and (for the moment) internally use the +% template mechanism. But this is more or less overkill and should +% probably be replaced in the end. +% \begin{macrocode} +\def\DeclareFloatArea#1#2{ + \xdef\known@areas{\known@areas#1} + \DeclareInstance{floatareasetup}{#1}{std} + { name = #1, #2 } +% \end{macrocode} +% We need to do some intialisation here in case the area isn't +% really used. (Since it is added to |\known@areas| it will be +% considered and that will die if the initialisation isn't done) +% \begin{macrocode} + \UseInstance{floatareasetup}{#1} +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macrocode} +\DeclareTemplateType{floatareasetup}{0} +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{floatareasetup}{std}{0}{ + name =n \floatareasetup@name, + class-close-list=n \floatareasetup@class@close, + all-close-list =n \floatareasetup@all@close, + max-float-num =C \floatareasetup@maxfloats, + } + { + + \DoParameterAssignments +% \end{macrocode} +% +% Declare area data structures if necessary\ldots +% \begin{macrocode} + \@ifundefined{\floatareasetup@name @float@count} + {\expandafter\newcount\csname \floatareasetup@name + @float@count\endcsname} + {} +% \end{macrocode} +% \ldots and initialise them +% \begin{macrocode} + \global\expandafter\let + \csname pagesetup@ \floatareasetup@name @float@num\endcsname + \floatareasetup@maxfloats + \global\expandafter\let + \csname pagesetup@ \floatareasetup@name @class@close\endcsname + \floatareasetup@class@close + \global\expandafter\let + \csname pagesetup@ \floatareasetup@name @all@close\endcsname + \floatareasetup@all@close +% \end{macrocode} +% Let's not forget that area itself (some macros wouldn't like if +% this is |\relax| rather than |\@empty|. +% \begin{macrocode} + \global\expandafter\let + \csname area@\floatareasetup@name\endcsname + \@empty +} +% \end{macrocode} +% +% +% \begin{macrocode} +\DeclareTemplateType{pagesetup2}{0} +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplate{pagesetup2}{std}{0}{ + column-num =+c \col@count, + column-width =+l \columnwidth, + column-height =+l \textheight, % FMi tmp + column-sep =+l \columnsep, + max-float-num =C \pagesetup@max@float@num, + float-callout-constraint =n \pagesetup@float@callout, + float-callout-span-constraint =n \pagesetup@float@callout@span, + bottom-float-footnote-constraint =n \pagesetup@float@footnote, + flush-float-callout-constraint =n \pagesetup@flush@float@callout, + flush-float-callout-span-constraint =n \pagesetup@flush@float@callout@span, + flush-bottom-float-footnote-constraint =n + \pagesetup@flush@float@footnote, +% +% \end{macrocode} +% +% \begin{macrocode} + area-list =n \pagesetup@area@list, +% \end{macrocode} +% \begin{macrocode} + defer-class-close-list=n \pagesetup@ddd@class@close, + defer-all-close-list =n \pagesetup@ddd@all@close, +% \end{macrocode} +% +% \begin{macrocode} + footnote-setup =i {footnotesetup} \pagesetup@footnote@setup, +% \end{macrocode} +% +% \begin{macrocode} + float-float-sep =+l \pagesetup@float@float@sep, + float-area-sep =+l \pagesetup@float@area@sep, + float-text-sep =+l \pagesetup@float@text@sep, + float-inline-sep =+l \pagesetup@float@inline@sep, +% \end{macrocode} +% +% \begin{macrocode} + grid-point-sep =+L \pagesetup@grid@point@sep, + } + { +% \end{macrocode} +% We start off with ensuring that we are at the top of a page. This +% is a temporary solution until after pagesetup is more settled and +% those bits which are only possible if there is nothing left on +% recent contributions are properly separated from those things +% which can be changed midway. +% \begin{macrocode} + \newpage + + \global\col@count\@ne + \def\pagesetup@max@float@num{3} + \def\pagesetup@float@callout{column} + \def\pagesetup@float@footnote{none} + \def\pagesetup@flush@float@callout{\pagesetup@float@callout} + \def\pagesetup@flush@float@footnote{\pagesetup@float@footnote} + \def\pagesetup@float@callout@span{flexible} + \def\pagesetup@flush@float@callout@span{\pagesetup@float@callout@span} +% \end{macrocode} +% +% \begin{macrocode} + \let\pagesetup@ddd@class@close\maxdimen %impossible value + \let\pagesetup@ddd@all@close\@empty +% \end{macrocode} +% +% \begin{macrocode} +% tmp: + \def\pagesetup@footnote@setup{\UseTemplate{footnotesetup}{std}{}} +% \end{macrocode} +% +% \begin{macrocode} + \global\let\pagesetup@grid@point@sep\z@ % no grid points by default + + \DoParameterAssignments +% \end{macrocode} +% +% \begin{macrocode} + \ifdim \pagesetup@grid@point@sep = \z@ + \global\let\snap@to@grid\dummy@snap@to@grid +% \end{macrocode} +% Next two lines need some refinement, we need some mechanism to +% fully disable those grid points. |\IgnoreAlignToGrid| doesn't do +% the trick.\footnote{FIX!} +% \begin{macrocode} + \IgnoreAlignToGrid + \global\let\std@AlignToGrid\relax + \else + \global\let\snap@to@grid\std@snap@to@grid + \ObeyAlignToGrid + \fi +% \end{macrocode} +% Split the |\pagesetup@float@text@sep| specification and store the +% minus part in |\pagesetup@float@text@shrink|. Right now the plus +% part is not used. Actually this is only really necessary if we do +% grid typesetting but we do it anyway so that the spec is always +% checked for offending infinite stretch. +% \begin{macrocode} + \split@skip{float-text-sep} + \pagesetup@float@text@sep + \dimen@ + {\global\pagesetup@float@text@shrink} +% \end{macrocode} +% +% \begin{macrocode} + \split@skip{float-inline-sep} + \pagesetup@float@inline@sep + \dimen@ + {\global\pagesetup@float@inline@shrink} + \global\pagesetup@float@inline@sep \@ne\pagesetup@float@inline@sep +% \end{macrocode} +% +% \begin{macrocode} + \global\hsize\columnwidth + \global\linewidth\columnwidth + +% all taken away from AtBeginDocument (where it is was added in xo-final) + \setlength \@tempdima {\headheight + \headsep} + \xdef \pagebodytopvpos {\the\@tempdima} + + \setlength \@tempdima {\@tempdima + \textheight} + \xdef \pagebodybotvpos {\the\@tempdima} + +%% horiz + \setlength \@tempdima {\columnwidth + \columnsep} + \xdef \columndisplacement {\the\@tempdima} + +% \end{macrocode} +% +% Perhaps we could use |\known@areas| instead and save the +% test (would need a change in xo-place as well!).\footnote{Check!} +% \begin{macrocode} + \ifx\pagesetup@ddd@class@close\maxdimen % not set? + \let\pagesetup@ddd@class@close\pagesetup@area@list + \fi +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \std@check@callout@constraints + {check@callout@\pagesetup@float@callout} + {float-callout-constraint} + {`none',~ `page',~ `column',~ or~ `after'} +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \relaxed@check@callout@constraints + {check@callout@\pagesetup@flush@float@callout} + {flush-float-callout-constraint} + {`none',~ `page',~ `column',~ or~ `after'} +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \std@check@some@constraints + {check@float@footnote@\pagesetup@float@footnote} + {bottom-float-footnote-constraint} + {`none'~ or~ `forbidden'} +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \relaxed@check@some@constraints + {check@float@footnote@\pagesetup@flush@float@footnote} + {flush-bottom-float-footnote-constraint} + {`none'~ or~ `forbidden'} +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \std@calculate@target@fl@column + {calculate@target@fl@column@\pagesetup@float@callout@span} + {float-callout-span-constraint} + {`strict'~ or~ `flexible'} +% \end{macrocode} +% +% \begin{macrocode} + \test@named@key + \relaxed@calculate@target@fl@column + {calculate@target@fl@column@\pagesetup@flush@float@callout@span} + {flush-float-callout-span-constraint} + {`strict'~ or~ `flexible'} +% \end{macrocode} +% +% \begin{macrocode} + \global\let\check@some@constraints\std@check@some@constraints + \global\let\check@callout@constraints\std@check@callout@constraints + \global\let\calculate@target@fl@column\std@calculate@target@fl@column +% \end{macrocode} +% +% \begin{macrocode} + \global\let\used@areas\@empty +% \end{macrocode} +% +% \begin{macrocode} + \expandafter + \@for \expandafter \@tempa \expandafter:\expandafter= + \pagesetup@area@list \do + { +% \end{macrocode} +% Perhaps the instance should be called the moment we declare the +% area. on the other hand calling it within the page setup would +% allow to use collections!\footnote{Think and decide} +% \begin{macrocode} + \xdef\used@areas{\used@areas\@tempa} +% after next line \@tempa is gone ... David, template.sty needs a cleanup + \UseInstance{floatareasetup}{\@tempa} +%\show\@tempa + } + +% \end{macrocode} +% +% \begin{macrocode} + \pagesetup@footnote@setup +% \end{macrocode} +% +% Finally another bit of the initalisation that we have to redo at +% this point since now some of the values may have +% changed.\footnote{Temporary solution until the initialisation bit +% and the pagesetup is properly sorted out.} +% \begin{macrocode} + \initialise@next@page + \setup@collection@or + } +% +% \end{macrocode} +% +% \begin{macrocode} +\endinput +% \end{macrocode} +% +% \endinput +% +% $Log: xo-page.dtx,v $ +% Revision 1.34 2000/08/11 07:14:27 latex3 +% added header +% +% Revision 1.33 2000/08/07 19:50:48 latex3 +% setup the collection@or again when a pagesetup is selected since its +% parameter might have changed. +% +% Revision 1.32 2000/08/06 19:02:51 latex3 +% move parts initialisation to \begin{document} +% move \newpage in pagesetup template first to ensure that previous page +% is finished with old values +% +% Revision 1.31 2000/08/06 09:02:57 latex3 +% documented that footnotehandling needs fixing +% +% Revision 1.30 2000/08/04 10:23:24 latex3 +% removed float-text-shrink and float-inline-shrink keys and instead +% used \split@skip +% +% Revision 1.29 2000/07/26 20:45:51 latex3 +% first implementation of grid point support +% +% Revision 1.28 2000/07/21 13:52:53 latex3 +% more renaming for float sequence class concept +% +% Revision 1.27 2000/07/18 21:07:03 latex3 +% introduced float sequence classes +% +% Revision 1.26 2000/07/12 16:47:44 latex3 +% use grid points properly in template +% +% Revision 1.25 2000/07/10 21:04:30 latex3 +% integration of float specing parameters in page setup +% support for grid typesetting in page setup +% +% Revision 1.24 2000/07/04 19:44:58 latex3 +% fix marginal footnote template (did change column calculations) +% +% Revision 1.23 2000/06/26 15:01:29 latex3 +% docu update +% +% Revision 1.22 2000/06/21 09:56:09 latex3 +% update docu +% +% Revision 1.21 2000/06/18 15:00:35 latex3 +% move "Bottom float footnote relation" to xo-place file +% +% Revision 1.20 2000/06/16 11:06:05 latex3 +% support float-callout-span-constraint +% +% Revision 1.19 2000/06/15 17:49:55 latex3 +% moved macros about placment checking to xo-place since they don't +% belong here +% +% Revision 1.18 2000/06/15 15:21:33 latex3 +% implemented new semantics for area names +% +% Revision 1.17 2000/06/13 21:21:08 latex3 +% added support for columnheight (tmp) +% define \pagebodytopvpos etc inside template so that it can change +% +% Revision 1.16 2000/05/03 18:48:42 latex3 +% initialise float area data structure the moment the float area is +% declared (otherwise you can't declare areas if they are not used!) +% +% add keys defer-type-close-list and defer-all-close-list to pagesetup2 +% template +% +% Revision 1.15 2000/04/21 19:03:58 latex3 +% added footnote setup +% cleanup pagesetup code +% +% Revision 1.14 2000/04/08 10:48:42 latex3 +% code cleanup +% +% Revision 1.13 2000/04/08 08:16:53 latex3 +% default for \pagesetup@flush@float@callout changed +% +% Revision 1.12 2000/03/31 17:07:24 latex3 +% don't fail in footnote/float test if there isn't any bottom area at +% all! +% +% Revision 1.11 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.10 2000/03/22 15:51:51 latex3 +% some normalisations of names +% +% Revision 1.9 2000/03/17 20:25:02 latex3 +% initialise fl@0 +% support relaxing constraints when flushing +% +% Revision 1.8 2000/03/15 19:58:00 latex3 +% assigning values to \column@number should always be done globally +% +% Revision 1.7 2000/03/05 19:41:21 latex3 +% support multiple columns (6 max right now) +% +% Revision 1.6 2000/02/26 18:21:16 david +% fixed footnote bottom constraint code +% +% Revision 1.5 2000/02/26 16:52:25 david +% *** empty log message *** +% +% Revision 1.4 2000/02/17 22:41:38 david +% *** empty log message *** +% +% Revision 1.4 2000/02/16 13:41:06 latex3 +% added 3col support +% +% Revision 1.3 2000/02/13 14:38:53 latex3 +% was 1.2.1.2 +% +% Revision 1.2.1.2 2000/02/13 11:51:27 latex3 +% fixed \check@callout@after (hopefully correct now) +% added \check@some@constraints logic +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-place.dtx b/Master/texmf-dist/source/latex3/xor/xo-place.dtx new file mode 100644 index 00000000000..0a208459540 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-place.dtx @@ -0,0 +1,1537 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-place.dtx,v 1.37 2000/08/11 07:14:28 latex3 Exp $ +% \end{macrocode} +% +% +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% +% \subsection{Selecting the next area to try} +% +% +% \begin{macro}{\std@try@this@area} +% The |\std@try@this@area| command is called when we have +% selected a float from the |\@activelist| and want to place it +% in one of the open areas to see if it fits there. If we succeed +% in finding a potential candidate place we will exit using +% |\contruct@trial| which will run a trial cutting the galley to +% see if each column gets the right kind of text and contains the +% right kind of callouts. +% The areas are tried in a defined order. +% +% If we don't find any open areas we return putting the current +% float onto the |\area@ddd| and then calling |\@trynextfloat|. +% +% If we find an open area but for some reason the float is not +% allowed to go there we close that area for floats of this type +% and recurse (i.e. try to use the next open area for this type). +% +% The reasons for failure to place the float into the first open +% area are numerous. First there are restrictions on the number of +% floats on a page (if we reach this all areas get closed) there +% there are similar restrictions for each individual float area. +% +% If those tests are passed we trial typeset the float with its +% caption (or rather typeset and attach its caption) to determine +% the size needed by the float. That will give us a dimension to +% test against restrictions for the amount of space floats are +% allowed to occupy etc. +% +% \begin{macrocode} +\def\std@try@this@area{ +%<*trace> + \@tracepush{std@try@this@area} +%</trace> +% \end{macrocode} +% If all areas for the float type are closed we have to defer this float. +% \begin{macrocode} + \ifx\this@open@areas\@empty +%<*trace> + \tr@ce{defer:~no~open~area~ available} +%</trace> + \do@next\defer@and@try@next@float + \else +% \end{macrocode} +% Otherwise the next area to try is the first of |\this@open@areas|: +% \begin{macrocode} + \setup@this@area{\expandafter\@carcube\this@open@areas\@nil} +%<*trace> + \tr@ce{area~trial:~ \this@area} +%</trace> +%<*progress> + \progress{~ area~trial:~ \this@area} +%</progress> +% \end{macrocode} +% Next test needs cleanup once the span has a decent data +% structure.\footnote{FIX!!} +% \begin{macrocode} + \ifnum \this@area@span@number = \if!\this@span@number! 1\else % big hack + \this@span@number \fi + \relax +%<*trace> + \tr@ce{span~ count~ okay:~ \this@area \space =~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \ifnum \pagesetup@max@float@num > \page@float@count +% \end{macrocode} +% +% \begin{macrocode} + \ifnum\csname pagesetup@\this@area @float@num\endcsname = + \csname \this@area @float@count \endcsname +% +% \end{macrocode} +% Current area doesn't accept any more floats, so try next one (if any) +% \begin{macrocode} +%<*trace> + \tr@ce{close~area:~\this@area\space float~num~reached ~ + (\csname pagesetup@\this@area @float@num\endcsname)} +%</trace> +%<*progress> + \progress@failed{\this@area\space float~num~reached ~ + (\csname pagesetup@\this@area @float@num\endcsname)} +%</progress> + \do@next\try@next@area +% \end{macrocode} +% +% \begin{macrocode} + \else + \xin@\this@area + \this@page@closed + \ifin@ +%<*trace> + \tr@ce{area~ closed~ for~ all~ types;~ member~ of~ + (\this@page@closed)} +%</trace> +%<*progress> + \progress@failed{area~ closed~ for~ all~ types} +%</progress> + \do@next\try@next@area + \else +%<*trace> + \tr@ce{area~ not~ closed~ for~ all~ types:~ not~ member~ of~ + (\this@page@closed)} +%</trace> + \xin@\this@area + \this@closed@areas + \ifin@ +%<*trace> + \tr@ce{area~ closed~ for~ class~ \this@class;~ member~ of~ + (\this@closed@areas)} +%</trace> +%<*progress> + \progress@failed + {area~ closed~ for~ class~ \this@class} +%</progress> + \do@next\try@next@area + \else +%<*trace> + \tr@ce{area~ open~ for~ class~ \this@class;~ not~ member~ of~ + (\this@closed@areas)} +%</trace> + \xin@\this@area\this@fps + \ifin@ +% + \append@caption@to@float + \construct@and@test@col@hts + \if@test + \do@next\try@next@area + \else + \do@next\pretests@success@action + \fi + + \else +%<*trace> + \tr@ce{close~area:~\this@area\space float~not~allowed~ + by~ user~ control~ (\this@fps)} +%</trace> +%<*progress> + \progress@failed{\this@area\space float~not~allowed~ + by~ user~ control~ (\this@fps)} +%</progress> + \do@next\try@next@area + \fi + \fi + \fi + \fi + \else +% defer + \global\let\this@open@areas\@empty +%<*trace> + \tr@ce{defer:~max~float~num~reached ~(\pagesetup@max@float@num)} +%</trace> +%<*progress> + \progress@failed{max~float~num~reached ~(\pagesetup@max@float@num)} +%</progress> + \do@next\defer@and@try@next@float + \fi + \else +%<*trace> + \tr@ce{span~ count~ unsuitable:~ \this@area \space /=~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</trace> +%<*progress> + \progress@failed{span~ count~ \this@area \space /=~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</progress> + \do@next\try@next@area + \fi + \fi +%<*trace> + \@tracepop{std@try@this@area} +%</trace> + \do@continue +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\do@next} +% Emergency macro to reduce the number of input levels (as the code +% got past the internal default of 300). This is because we have a +% lot of recursion going on without being tail +% recursion. Essentially this means some of the code needs slightly +% different implementation.\footnote{fix} +% \begin{macrocode} +\def\do@next{\let\do@continue} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\relaxed@try@this@area} +% \begin{macrocode} +\def\relaxed@try@this@area{ +%<*trace> + \@tracepush{relaxed@try@this@area} +%</trace> +% \end{macrocode} +% If all areas for the float type are closed we have to defer this float. +% \begin{macrocode} + \ifx\this@open@areas\@empty +%<*trace> + \tr@ce{defer:~no~open~area~ available} +%</trace> + \do@next\defer@and@try@next@float + \else +% \end{macrocode} +% Otherwise the next area to try is the first of |\this@open@areas|: +% \begin{macrocode} + \setup@this@area{\expandafter\@carcube\this@open@areas\@nil} +%<*trace> + \tr@ce{area~trial:~ \this@area} +%</trace> +%<*progress> + \progress{~ area~trial:~ \this@area} +%</progress> +% \end{macrocode} +% Next test needs cleanup once the span has a decent data +% structure.\footnote{FIX!!} +% \begin{macrocode} + \ifnum \this@area@span@number = \if!\this@span@number! 1\else % big hack + \this@span@number \fi + \relax +%<*trace> + \tr@ce{span~ count~ okay:~ \this@area \space =~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</trace> +% \end{macrocode} +% +% \begin{macrocode} + \xin@\this@area\this@page@closed + \ifin@ +%<*trace> + \tr@ce{area~ closed~ for~ all~ types;~ member~ of~ + (\this@page@closed)} +%</trace> +%<*progress> + \progress@failed{area~ closed~ for~ all~ types} +%</progress> + \do@next\try@next@area + \else +%<*trace> + \tr@ce{area~ not~ closed~ for~ all~ types:~ not~ member~ of~ + (\this@page@closed)} +%</trace> + \xin@\this@area + \this@closed@areas + \ifin@ +%<*trace> + \tr@ce{area~ closed~ for~ class~ \this@class;~ member~ of~ + (\this@closed@areas)} +%</trace> +%<*progress> + \progress@failed + {area~ closed~ for~ class~ \this@class} +%</progress> + \do@next\try@next@area + \else +%<*trace> + \tr@ce{area~ open~ for~ class~ \this@class;~ not~ member~ of~ + (\this@closed@areas)} +%</trace> + \append@caption@to@float + \construct@and@test@col@hts + \if@test + \do@next\try@next@area + \else + \do@next\pretests@success@action + \fi + \fi + \fi + \else +%<*trace> + \tr@ce{span~ count~ unsuitable:~ \this@area \space /=~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</trace> +%<*progress> + \progress@failed{span~ count~ \this@area \space /=~ + \if!\this@span@number! 1\else % big hack + \this@span@number \fi} +%</progress> + \do@next\try@next@area + \fi + \fi +%<*trace> + \@tracepop{relaxed@try@this@area} +%</trace> + \do@continue +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \begin{macro}{\construct@and@test@col@hts} +% The |\construct@and@test@col@hts| loops over all columns +% affected by the float area we want to place our float into +% and reduces the column size as +% needed. It sets the switch |@test| to true in case the float +% doesn't fit into area for some reason. It is up to the calling +% macro to take proper action in this case (including resetting +% column heights to their former values). +% \begin{macrocode} +\def\construct@and@test@col@hts { +% \end{macrocode} +% We use the information from the area not from the float (which +% allows us to put small floats into larger areas. +% \begin{macrocode} + \update@this@area@columns + { + \expandafter + \construct@and@test@col@ht + \csname col@ht@ \the\count@ \endcsname + {\the\count@} +% \end{macrocode} +% We need to break out of the updating loop if we found a column that +% doesn't work, a) to save time and b) since the +% |\construct@and@test@col@ht| resets the switch again to false +% (in the current implementation). +% \begin{macrocode} + \if@test + \count@\z@ % break out of loop + \fi + } +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\construct@and@test@col@ht} +% The |\construct@and@test@col@ht| reduces the height of one column +% by the size of the current float (plus some suitable extra space) +% and tests if this reduction is possible/allowed. It sets the +% switch |@test| to true if it encounters a problem. +% \begin{macrocode} +\def\construct@and@test@col@ht#1#2{ +%<*trace> + \tr@ce{col height~before:~ \the#1 (\string#1)} +%</trace> +% \end{macrocode} +% In |\@tempdima| we calculate the amount of space we need if we +% place the float. This is the size of the float, i.e., its height +% and depth, plus either |\pagesetup@float@text@sep| if this is the +% very first float in this column (on top or on bottom), or +% |\pagesetup@float@area@sep| if it is the first float in the +% current area, or |\pagesetup@float@float@sep| if we already have +% floats in this area. +% \begin{macrocode} + \@tempdima \ht\this@captioned@float + \advance \@tempdima \dp\this@captioned@float + \ifnum \csname col@ \this@area@type + @floats@#2@number\endcsname + = \z@ +%<*trace> + \tr@ce{first~ float~ in~ any~ \this@area@type\space + in~ column~ #2:~ + adding~ \string\pagesetup@float@text@sep + =\the\pagesetup@float@text@sep} +%</trace> + \advance \@tempdima \pagesetup@float@text@sep + \else + \advance \@tempdima + \expandafter + \ifx \csname area@\this@area\endcsname\@empty + \pagesetup@float@area@sep +%<*trace> + \tr@ce{first~ float~ in~ \this@area :~ + adding~ \string\pagesetup@float@area@sep + =\the\pagesetup@float@area@sep} +%</trace> + \else + \pagesetup@float@float@sep +%<*trace> + \tr@ce{additional~ float~ in~ \this@area :~ + adding~ \string\pagesetup@float@float@sep + = \the\pagesetup@float@float@sep} +%</trace> + \fi + \fi +% \end{macrocode} +% Now we make the area size fully fall into the page grid (if there +% is one). To do this we first substract any delta that has been +% accumulated for the column (to get back to the real size) and +% then run |\snap@to@grid| to get the next grid point. +% \begin{macrocode} + \advance \@tempdima + -\csname col@ \this@area@type @delta@ #2 \endcsname \relax +% \end{macrocode} +% The |\col@|\meta{area-type}|@delta@|\meta{col} are macros but +% fortunately low-level \TeX{} supports register assignments of the +% form |--3pt| so the above will work even if the macro contains a +% negative value. +% \begin{macrocode} + \snap@to@grid \@tempdima \pagesetup@grid@point@sep +% \end{macrocode} +% +% If the distance to the next grid point is larger than the +% distance to the previous one, and if the space between floats and +% text is allowed to shrink by the needed amount we will use the +% previous grid point. +% \begin{macrocode} + \ifdim \returned@lower@delta@size < \returned@delta@size \relax + \ifdim \returned@lower@delta@size < \pagesetup@float@text@shrink +%<*trace> + \tr@ce{GRID:~ column~#2:~ choosing~ lower~ grid~ point} +%</trace> +% \end{macrocode} +% We do this by copying the |\returned@lower@...| to the macros +% used below. Note that for the delta size we have to use the +% negation since we want to backup by this amount and delta sizes +% are always given in absolute values. +% \begin{macrocode} + \global\let \returned@size \returned@lower@size + \xdef \returned@delta@size {-\returned@lower@delta@size } + \fi + \fi +%<*trace> + \tr@ce{GRID:~ column~#2:~ \the\@tempdima\space ->~ \returned@size} +%</trace> + \@tempdima \returned@size +% \end{macrocode} +% +% After updating |\@tempdima| in this way we now have to check if +% the space remaining for the text column is large enough. +% \begin{macrocode} + \@tempdimb#1 + \advance \@tempdimb -\@tempdima + \@testfalse + \ifdim \textminlines\baselineskip > \@tempdimb +% \end{macrocode} +% If not we bail out +% \begin{macrocode} + \@testtrue +%<*trace> + \tr@ce{close~area:~\this@area\space not~ enough~ text~ lines~ + left~ + (\textminlines x\the\baselineskip> \the\@tempdimb)} +%</trace> +%<*progress> + \progress@failed{not~ enough~ text~ space~ + (\textminlines x\the\baselineskip\space + >~ \the\@tempdimb)} +%</progress> + \else +% \end{macrocode} +% Otherwise we have to update the column heights (and their saved +% version in case we back out later) as well as storing the new +% delta (which is still in |\returned@delta@size|). +% \begin{macrocode} +%<*trace> + \tr@ce{saved@col@ht@ #2~ <-~\the#1} +%</trace> + \expandafter\xdef + \csname saved@col@ht@ #2\endcsname{\the#1} + \global#1\@tempdimb + \global\expandafter\let + \csname saved@col@ \this@area@type @delta@ #2 \expandafter \endcsname + \csname col@ \this@area@type @delta@ #2 \endcsname + \global\expandafter\let + \csname col@ \this@area@type @delta@ #2 \endcsname + \returned@delta@size +%<*trace> + \tr@ce{GRID (delta):~ column~#2\this@area@type:~ + \csname saved@col@ \this@area@type @delta@ #2 + \endcsname\space ->~ \returned@delta@size} +%</trace> + \fi +%<*trace> + \tr@ce{col height~after:~ \the#1} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\textminlines} +% Tmp definition; should be interfaced to pagesetup. +% \begin{macrocode} +\def\textminlines{4} +% \end{macrocode} +% \end{macro} +% +% +% +% \subsection{Supporting grid based designs} +% +% +% +% \begin{macro}{\pagesetup@grid@point@sep} +% |\pagesetup@grid@point@sep| is the distance between grid points +% for page design or 0pt if we are not doing grid design. +% \begin{macrocode} +\let\pagesetup@grid@point@sep\ERROR +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\snap@to@grid} +% |\snap@to@grid| takes a dimension as first argument and a +% ``grid-size'' as second argument and from those two values +% calculates a new dimension which is a multiple of the grid-size +% and equal or larger than the first argument. +% +% It returns this calculated value globally in |\returned@size|. In +% addition it will return in |\returned@delta@size| the delta +% between the original and the new dimension. +% +% It also returns a lower or equal grid point in +% |\returned@lower@size| and the delta to it (absolute value) in +% |\returned@lower@delta@size|. +% +% Thus the first argument lies on a grid point if and only if +% |\returned@size| equals |\returned@lower@size|. +% +% If we are not doing grid typesetting then |\snap@to@grid| is +% actually a dummy which will return always the first argument in +% |\returned@size| and |\returned@lower@size|, and |0pt| in the +% deltas. +% +% The actual definition is assigned within the page setup. +% \begin{macrocode} +\let\snap@to@grid\ERROR +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\dummy@snap@to@grid} +% In case we don't do grids we simply pretend that all sizes lie on +% grid points. +% \begin{macrocode} +\def \dummy@snap@to@grid #1#2{ + \begingroup +% \end{macrocode} +% Definitions below can be optimised for speed but the ones used +% give better tracing. +% \begin{macrocode} + \@tempdima #1 \relax + \xdef \returned@size { \the\@tempdima } + \global\let \returned@lower@size \returned@size + \gdef \returned@delta@size {0pt} + \global\let \returned@lower@delta@size \returned@delta@size + \endgroup +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\std@snap@to@grid} +% But if we do grid typesetting we have to do a bit more work +% here. +% \begin{macrocode} +\def \std@snap@to@grid #1#2{ +% \end{macrocode} +% Everything is done in a group so that the register change do not +% affect other parts of the code. +% \begin{macrocode} + \begingroup +% \end{macrocode} +% First we calculate in |\@tempdimc| the nearest grid point which +% is smaller or equal to the given size in |#1| by using scaled +% point arithmetic. +% \begin{macrocode} + \@tempdima #1\relax + \@tempdimb #2\relax + \@tempcnta \@tempdima % orig size in sp + \@tempcntb \@tempdimb % grid size in sp + \divide \@tempcnta \@tempcntb + \@tempdimc \@tempcnta\@tempdimb +% \end{macrocode} +% If the calculated grid point is smaller than the original +% dimension use the next larger one. But record the other in +% |\returned@lower@size|. +% \begin{macrocode} + \ifdim \@tempdimc < \@tempdima + \xdef \returned@lower@size { \the\@tempdimc } + \advance\@tempdimc \@tempdimb + \fi +% \end{macrocode} +% The |\returned@size| will be whatever the result of the above is +% and |\returned@delta@size| the difference to the given value in +% |#1|. Note that |\returned@size| will always be larger or equal +% to this value so the difference computed below will also be +% non-negative! +% \begin{macrocode} + \xdef \returned@size { \the\@tempdimc } + \advance \@tempdimc -\@tempdima + \xdef \returned@delta@size { \the\@tempdimc } +% \end{macrocode} +% Now if this difference turns out to be zero then we actually +% started with a dimension exactly on a grid point. In this case we +% better define both |\returned@lower@size| and +% |\returned@lower@delta@size| to equal their counterparts. +% \begin{macrocode} + \ifdim \@tempdimc = \z@ + \global \let \returned@lower@size \returned@size + \global \let \returned@lower@delta@size \returned@delta@size +% \end{macrocode} +% Otherwise we only have to compute |\returned@lower@delta@size| +% since in that case we already recorded |\returned@lower@size| +% above (and we better had since by now we lost this information as +% we reused |\@tempdimc|). Now the value for this macro should be +% the difference between |\returned@delta@size| and our grid size +% both of which are already stored in some temp registers, +% thus\ldots +% \begin{macrocode} + \else + \advance\@tempdimb-\@tempdimc + \xdef \returned@lower@delta@size { \the\@tempdimb } + \fi + \endgroup +%<*trace> + \tr@ce{GRID:~ \string\returned@lower@size=\returned@lower@size} + \tr@ce{GRID:~ \string\returned@lower@delta@size=\returned@lower@delta@size} + \tr@ce{GRID:~ \string\returned@size=\returned@size} + \tr@ce{GRID:~ \string\returned@delta@size=\returned@delta@size} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% \subsection{Deferring a float} +% +% +% +% \begin{macro}{\really@defer@and@try@next@float} +% \begin{macrocode} +\def\really@defer@and@try@next@float{ +%<*progress> + \progress@failed{-->~ defer} + \progress@nl{} +%</progress> + \@cons\area@ddd\this@float@box +%<*trace> + \tr@ce{this@page@closed~ <-~ "\this@page@closed"~ +~ + "\pagesetup@ddd@all@close"} +%</trace> + \xdef\this@page@closed{\this@page@closed, + \pagesetup@ddd@all@close} + + \ifx\pagesetup@ddd@class@close\pagesetup@area@list +%<*trace> + \tr@ce{this@closed@areas~ <-~ + "\pagesetup@ddd@class@close"~ (all~ closed)} +%</trace> + \global\let\this@closed@areas\pagesetup@ddd@class@close + \else +%<*trace> + \tr@ce{this@closed@areas~ <-~ "\this@closed@areas"~ +~ + "\pagesetup@ddd@class@close"} +%</trace> + \xdef\this@closed@areas{\this@closed@areas, + \pagesetup@ddd@class@close} + \fi + + \global\expandafter\let\csname closed@\this@class + @areas\endcsname % FMi tmp + \this@closed@areas + \try@next@float +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\defer@and@try@next@float} +% +% This code either defers the current float and restarts by calling +% |\try@next@float| or recurses after relaxing the placement +% conditions (in case the current float should be flushed). +% +% If the placement conditions are already relaxed we move the first +% flush point that affects the current float one column forward and +% then retry. This might result in succeding to place the float, if +% not it will ultiamtely result in the flush point being moved from +% the page at which point the float can be deferred. +% +% \begin{macrocode} +\def\defer@and@try@next@float{ +%<*trace> + \@tracepush{defer@and@try@next@float} +%</trace> +% \end{macrocode} +% If there have been no flush points or if the flush points seen do +% not affect the current float we can immediately defer it. +% \begin{macrocode} + \if@flushseen + \xin@\this@class\flush@classes@list@max + \ifin@ +%<*trace> + \tr@ce{flush:~ class~ \this@class\space in~ + \flush@classes@list@max} +%</trace> +% \end{macrocode} +% First test is just there to avoid doing any of the loops +% (might not be worth having) +% \begin{macrocode} + \ifnum \csname flush@min@col@1\endcsname > \curr@col@count +%<*trace> + \tr@ce{flush:~ no~ flush~ points~ on~ page;~ defer} +%</trace> + \do@next\really@defer@and@try@next@float + \else +% \end{macrocode} +% +% The code is often invoked before there is an attempt to split the +% galley; this means we don't know which flush point affects the +% current float and thus have to manually get at it. +% +% So we loop through the |\flush@last@float@|\meta{num} values to +% find the first one that a) affects the current float type and b) +% holds a sequence number that is higher or equal to the sequence +% number of the current float. +% \begin{macrocode} + \count@ \@ne + \loop +% \end{macrocode} +% If |\count@| is greater than |\flush@seq@num| we have exhausted +% all possible flush points without finding a candidate. +% \begin{macrocode} + \ifnum \flush@seq@num < \count@ + \in@false + \else +% \end{macrocode} +% Otherwise, if |\this@sequence@number| is greater than +% |\flush@last@float@|\meta{num} the current flush point is before +% the call-out to the current float. +% \begin{macrocode} +%<*trace> + \tr@ce{flush:~ \this@sequence@number \space ???~ + \csname flush@last@float@ \the\count@ \endcsname} +%</trace> + \ifnum \this@sequence@number > + \csname flush@last@float@ \the\count@ \endcsname + \relax +% \end{macrocode} +% We set |\in@true| to get a repeat below with a new value of +% |\count@|. +% \begin{macrocode} + \in@true + \else +% \end{macrocode} +% Otherwise we have a flush point that is later in the galley in +% comparison to the call-out of the current float thus potentially +% affects it. Therefore we now have to check if the sequence class +% of the current float is affected by the flush point found: +% \begin{macrocode} + \expandafter\xin@\expandafter\this@class + \csname flush@classes@list@ \the\count@ \endcsname +% \end{macrocode} +% Now we could make good use of the |\unless| primitive of +% e\TeX. But since we want to run with standard \TeX{} and don't +% have |\xnotin@| available we invert the result. +% \begin{macrocode} + \ifin@ + \in@false + \else + \in@true +%<*trace> + \tr@ce{flush:~ class~ \this@class\space not~ in~ + \csname flush@classes@list@ \the\count@ \endcsname + \space (ignored) + } +%</trace> + \fi + \fi + \fi + \ifin@ + \advance\count@\@ne + \repeat +%<*trace> + \tr@ce{flush:~ first~ float~ point~ after~ float~ =~ + \the\count@} +%</trace> + \ifnum \flush@seq@num < \count@ +%<*trace> + \tr@ce{flush:~ this~ float~ past~all~flush~ points;~ defer} +%</trace> + \do@next\really@defer@and@try@next@float + \else +% \end{macrocode} +% Once a |flush@min@col| is larger than |\curr@col@count| it has +% moved to the next page. In particular this is true for the +% artificial value |\maxdimen| to which it is sometimes set to +% denote this fact. If so we can defer our float. +% \begin{macrocode} + \ifnum \csname flush@min@col@\the\count@\endcsname + > \curr@col@count +%<*trace> + \tr@ce{flush:~ float~ past~ all~ flush~ points~ + on~ current~ page;~ defer} +%</trace> + \do@next\really@defer@and@try@next@float + \else +% \end{macrocode} +% If we have already relaxed the conditions and we are still in +% conflict with a flush point on the current page we nearly ran out +% of options. In this case we are forced to move the flush point, +% but rather than moving it to the next page and defering the float +% we can move it one column further (which might make it fall off +% the page though) and then retry to place the float since we have +% now more space available. +% \begin{macrocode} + \ifx\try@this@area\relaxed@try@this@area +%<*trace> + \tr@ce{flush:~ defer~ forced;~ move~ + flush~ point~ columns} +%</trace> +%<*progress> + \progress@nl{} + \progress@nl{Flushing~ impossible~ -->~ breaking~ + before~ flush~ point~ and~ retry} +%</progress> +% \end{macrocode} +% We should only increment the |flush@min@col@| value of the first +% flush point that affects our float (this will automatically move +% later flush points if necessary). Incrementing the later ones is +% incorrect as they might not need moving! +% \begin{macrocode} + \expandafter \gincrement@num + \csname flush@min@col@ \the\count@ \endcsname +%<*trace> + \tr@ce{flush@min@col@\the\count@ \space <-~ + \csname flush@min@col@ \the\count@ \endcsname + } +%</trace> +%<*progress> + \progress@nl{} + \progress@nl{Defer~ impossible~ -->~ moving~ + flush~ point~ to~ column~ + \csname flush@min@col@ \the\count@\endcsname + \space + and~ retry} +%</progress> +% \end{macrocode} +% Not clear that it is really necessary to check all areas again, +% but it is late (after midnight) and it is definitely not +% wrong.\footnote{Check!} +% \begin{macrocode} + \relax@float@placement@conditions % needed to reset open areas + \do@next\try@this@area + + \else +% \end{macrocode} +% +% \begin{macrocode} + \relax@float@placement@conditions + \do@next\try@this@area + \fi + \fi + \fi + \fi + \else +%<*trace> + \tr@ce{flush:~ class~ \this@class\space not~ in~ + \flush@classes@list@max;~ defer} +%</trace> + \do@next\really@defer@and@try@next@float + \fi + + \else +%<*trace> + \tr@ce{flush:~ no~ flush~ point~ seen; defer} +%</trace> + \do@next\really@defer@and@try@next@float + \fi + +%<*trace> + \@tracepop{defer@and@try@next@float} +%</trace> + \do@continue +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\relax@float@placement@conditions} +% \begin{macrocode} +\def \relax@float@placement@conditions { +%<*progress> + \progress@failed{-->~ retry~ with~ relaxed~ conditions} + \progress@nl{} +%</progress> +%<*trace> + \tr@ce{flush:~relax~placement~conditions} +%</trace> + \global\let\try@this@area\relaxed@try@this@area +% next line perhaps external? + \global\let\this@open@areas\saved@this@open@areas + + \global\let\check@some@constraints\relaxed@check@some@constraints + \global\let\check@callout@constraints\relaxed@check@callout@constraints + \global\let\calculate@target@fl@column\relaxed@calculate@target@fl@column +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\tighten@float@placement@conditions} +% \begin{macrocode} +\def\tighten@float@placement@conditions { +%<*trace> + \tr@ce{flush:~tighten~placement~conditions} +%</trace> + \global\let\try@this@area\std@try@this@area + + \global\let\check@some@constraints\std@check@some@constraints + \global\let\check@callout@constraints\std@check@callout@constraints + \global\let\calculate@target@fl@column\std@calculate@target@fl@column +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\partly@tighten@float@placement@conditions} +% This is used when we have placed the last float that is affected +% by a certain flush point. We don't want to tighten up completely +% since this would essentially mean that we can't place any further +% floats since callout relationships etc might be violated for +% them. Good question is whether or not the last restriction should +% be used again since this too might prevent any further placements. +% \begin{macrocode} +\def\partly@tighten@float@placement@conditions { +%<*trace> + \tr@ce{flush:~partly~tighten~placement~conditions} +%</trace> + \global\let\try@this@area\std@try@this@area + +% \global\let\check@some@constraints\std@check@some@constraints +% \global\let\check@callout@constraints\std@check@callout@constraints + \global\let\calculate@target@fl@column\std@calculate@target@fl@column +} +% \end{macrocode} +% \end{macro} +% +% +% +% \subsection{Checking float placement during trial} +% +% The interface to checking float placement in relation to its callout +% is the following piece of code in |\grab@column@or|: +%\begin{verbatim} +% \let\@elt\check@callout@constraints +% \float@classes@list +%\end{verbatim} +% This loops through all float types and executes +% |\check@callout@constraints| with the float type as an argument. The output +% routine |\grab@column@or| itself is called for each column of a trial +% configuration, thus the above loop is called for each column +% individually (|\curr@col@count| can be used to determine the current +% column number). +% +% By giving |\check@callout@constraints| an appropriate definition a +% pagesetup template can implement different relationships between +% callout and float. +% +% Possible tests (getting stronger): +% \begin{itemize} +% +% \item +% Don't check, i.e., add the float when you find it and it fits +% according to other criteria (like number of floats in the area, +% etc.). This is implemented in |\check@callout@none|. +% +% +% \item +% Check if callouts for all floats on the page (not column) are +% either on the same page or on an earlier page; i.e., callout can be +% late as long as the float is visible from the callout. +% +% Fail if for last column and all float types: +% last callout number for float type is smaller than maximum last float +% of type put into any column.\footnote{This description is +% probably wrong} +% +% This is implemented in |\check@callout@page|. +% +% \item +% Check if callouts for all floats in the column are either on the +% same column or on an earlier column. +% +% Fail if for any column and any float type: +% last callout number for float type is smaller last float sequence +% number for type recorded for this column. +% +% This case consists in fact of two subcases depending on how we +% interpret to which column a spanning float belongs. If we claim +% that a spanning float is placed into its starting column, then we +% fail if its call-out is in a later column even though this column +% might still be spanned by the float area. +% +% This is implemented in |\check@callout@column|. +% +% \item +% Check if callouts for all floats in the column are on an earlier +% column or if on the same column the float was added to the bottom +% (or marginal) area; i.e. strict float/callout order +% +% Fail if for each type and for any column: +% `top' callout number less than `top' float number +% (at top of text column) +%\begin{verbatim} +% [Corectness proof: +% TRUE => first callout's float comes before bottom +% and so comes too early +% => FAIL +% FALSE => first callout's float comes in bottom and all other +% callouts come later and so are in bottom or beyond +% => OK +% ] +%\end{verbatim} +% The proof above is in fact only valid if you look at the whole +% document and not only at a single page since a float in the bottom +% area of the last column with its callout on the next page will +% only be detected when testing the next page. Therefore one needs +% an additional check of type |\check@callout@column|. +% +% This is implemented in |\check@callout@after|. +% +% +% \end{itemize} +% +% +% \begin{macro}{\check@callout@none} +% This test is an easy one: just do nothing, i.e., gobble the argument. +% \begin{macrocode} +\let\check@callout@none\@gobble +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\check@callout@page} +% We are are only interested in the callout/float relation per page +% we only have to do a check when producing the last column, i.e., +% when |\curr@col@count| is |\col@count|. +% \begin{macrocode} +\def\check@callout@page#1{ +%<*trace> + \@tracepush{check@callout@page} +%</trace> + \ifnum\curr@col@count=\col@count +% \end{macrocode} +% We store in |\fl@max| the highest sequence number for floats of +% the current type up to the end of the page. For this we have to +% find the maximum of |\fl@0@|\meta{type} (highest float number on +% previous pages) and those for the columns, e.g., +% |\fl@|\meta{colnum}|@|\meta{type}; this is done by the following +% code: +% \begin{macrocode} + \global\expandafter\let\expandafter\fl@max + \csname fl@0@#1\endcsname + \forall@columns { + \ifnum\csname fl@\the\curr@col@count @#1\endcsname>\fl@max\relax + \xdef\fl@max{\csname fl@\the\curr@col@count @#1\endcsname} + \fi + } +% \end{macrocode} +% We then store the number of the last callout in |\count@|; the +% |0| will take care of the potential problem that there was never any +% callout so far. And we better have a |\relax| afterwards since +% otherwise we will expand the |\ifnum| before we have finished +% assigning the |\count@|. +% \begin{macrocode} + \count@0\LastMark{#1}\relax +%<*trace> + \tr@ce{Last~callout~ (#1)~ =~ \the\count@} +%</trace> +% \end{macrocode} +% Now we have to compare those two numbers to find out if that +% trial has failed: +% \begin{macrocode} + \ifnum\count@<\fl@max\relax + \@failtrue +%<*progress> + \progress@failed{last~callout~ + \the\count@\space~<~\fl@max + \space last~float~put~on~page~or~ earlier} +%</progress> +%<*trace> + \tr@ce{Failed:~(#1)~ last~callout~ + \the\count@\space~<~\fl@max + \space last~float~put~on~page~or~ earlier} + \else + \tr@ce{OK:~(#1)~ last~callout~ + \the\count@\space~>=~\fl@max + \space last~float~put~on~page~or~ earlier} +%</trace> + \fi + \fi +%<*trace> + \@tracepop{check@callout@page} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% \begin{macro}{\fl@max} +% The macro |\fl@max| is used within |\check@callout@page| to hold +% the highest sequence number of any allocated float on the current +% page for the type under testing. It will be recalculated on +% each pass.\footnote{One could generate this value while running through +% the trials --- this would perhaps be a bit more time efficient.} +% \begin{macrocode} +\let\fl@max\ERROR +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\check@callout@column} +% Checking each column separately means we have to compare for each +% type the last callout on this or previous columns (i.e., as +% returned by |\LastMark|) with the highest sequence number for +% floats of this type in the current column (as stored in +% |fl@|\meta{col}|@|\meta{type}). So we first store the callout +% info in |\count@|. +% \begin{macrocode} +\def\check@callout@column#1{ +%<*trace> + \@tracepush{check@callout@column} +%</trace> + \count@0\LastMark{#1}\relax +% \end{macrocode} +% Then we do the test. If there are no floats of the current type +% in the current column |\fl@|\meta{col}|@|\meta{type} will be zero +% and thus the following test will come out true. This is the +% correct behaviour as any callouts that might be present will be +% correctly evaluated in tests on neighboring columns with floats. +% \begin{macrocode} + \ifnum\count@<\csname fl@\the\curr@col@count @#1\endcsname\relax +%<*progress> + \progress@failed{last~ callout~ + \the\count@\space <~ + \csname fl@\the\curr@col@count @#1\endcsname + \space last~ float~ placed~ in~ column~ \the\curr@col@count} +%</progress> +%<*trace> + \tr@ce{Failed:~(#1)~ last~ callout~ + \the\count@\space <~ + \csname fl@\the\curr@col@count @#1\endcsname + \space last~float~placed} +%</trace> +% \end{macrocode} +% If the test fails we abort this trial by setting the switch +% |@fail| to true. We also set +% |\curr@col@count| to |\col@count| which will save us any further +% iteration (in case this wasn't the last column). Finally we +% locally set |\@elt| to |\@gobble| which will essentially about +% the current loop through the |\float@classes@list|. +% \begin{macrocode} + \@failtrue + \global\curr@col@count\col@count + \let\@elt\@gobble +% \end{macrocode} +% Otherwise the constraints for callout of current float type are +% met so we report this fact if we do tracing. +% \begin{macrocode} +%<*trace> + \else + \tr@ce{OK:~(#1)~ last~ callout~ + \the\count@\space >=~ + \csname fl@\the\curr@col@count @#1\endcsname + \space last~float~placed} +%</trace> + \fi +%<*trace> + \@tracepop{check@callout@column} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\check@callout@after} +% +% \begin{macrocode} +\def\check@callout@after#1{ +%<*trace> + \@tracepush{check@callout@after} +%</trace> +% \end{macrocode} +% +% We first check if all floats are either on the same column than +% their callout or on an later column by calling +% |\check@callout@column|. If this returns |@fail| we immediately +% abort any further processing. +% \begin{macrocode} + \check@callout@column{#1} + \if@fail\else +% \end{macrocode} +% +% If the above check found no violation we have to check for top +% area floats that might preceed their callouts. +% +% For this we look at the value of the +% |\tfl@|\meta{col}|@|\meta{float-type} macro which holds the +% highest float sequence number for floats of this type allocated +% in that column. +% \begin{macrocode} + \global\expandafter\let\expandafter + \returned@sequence@number + \csname tfl@\the\curr@col@count @#1\endcsname +% \end{macrocode} +% +% If there was no float in the top area we get |0| back and in +% that case we are done since all our constraints are met. +% \begin{macrocode} + \ifnum \returned@sequence@number = \z@ +%<*trace> + \tr@ce{OK:~(#1)~ top~ areas~ have~ no~ floats} +%</trace> + \else +% \end{macrocode} +% +% Otherwise we have to look at the top callout number and compare +% it to the last float number of the top area. +% \begin{macrocode} + \count@ 0\PreviousMark{#1}\relax +% \end{macrocode} +% If that callout number is less than the last float number we +% failed since this means that there is a float in the top area +% which callout has not yet been seem. So we abort the +% trial. Otherwise our constraints are met. +% \begin{macrocode} + \ifnum \count@ < \returned@sequence@number \relax +% \end{macrocode} +% But before aborting we give some information on why we +% failed. This has to come first since we change |\curr@col@count| +% below. +% \begin{macrocode} +%<*progress> + \progress@failed{top~ callout~ + \the\count@\space <~ \returned@sequence@number + \space last~ float~ put~ in~ top~ + of~ column~ \the\curr@col@count} +%</progress> + \@failtrue + \global\curr@col@count\col@count + \let\@elt\@gobble +%<*trace> + \tr@ce{Failed:~(#1)~ top~ callout~ + \the\count@\space <~ \returned@sequence@number + \space last~float~put~in~top} + \else + \tr@ce{OK:~(#1)~ top~ callout~ + \the\count@\space >=~ \returned@sequence@number + \space last~float~put~in~top} +%</trace> + \fi + \fi + \fi +%<*trace> + \@tracepop{check@callout@after} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Checking bottom float footnote constraints} +% +% In |\grab@column@or|, the output routine that grabs a single column +% during a trial, we have the command |\check@some@constraints| which +% allows to check some constraints and if they aren't met is supposed +% to set the switch |@fail|. +% +% This can, for example be used to implement a constraint that bottom +% floats are only allowed if there are no footnotes in the current +% column.\footnote{At the moment this is restricted to single column +% floats. Spanning floats are always allowed.} +% +% \begin{macro}{\check@float@footnote@forbidden} +% The command |\check@float@footnote@forbidden| is the +% implementation for |\check@some@constraints| that prevents bottom +% floats if the current column contains footnotes. +% \begin{macrocode} +\def\check@float@footnote@forbidden{ +%<*trace> + \@tracepush{check@float@footnote@forbidden} +%</trace> + \ifvoid\footins + \else +% \end{macrocode} +% If the current column contains footnotes and we have bottom +% floats we fail. First we check if there is a bottom area for this +% column defined if not we pretend there is an empty one. +% \begin{macrocode} + \expandafter + \ifx \csname area@b\the\curr@col@count1\endcsname + \relax + \global\expandafter\let + \csname area@b\the\curr@col@count1\endcsname + \@empty + \fi +% \end{macrocode} +% Then we check if the bottom area is empty and fail otherwise +% \begin{macrocode} + \expandafter + \ifx \csname area@b\the\curr@col@count1\endcsname + \@empty +%<*trace> + \tr@ce{OK:~ no~ old~ bottom~ floats} +%</trace> + \else +%<*progress> + \progress@failed{old~bottom~floats:~ \expandafter\meaning + \csname area@b\the\curr@col@count1\endcsname} +%</progress> +%<*trace> + \tr@ce{Failed:~ old~bottom~floats:~ \expandafter\meaning + \csname area@b1\the\curr@col@count\endcsname} +%</trace> + \@failtrue + \fi +% \end{macrocode} +% Finally we test if the float we are try to place is going onto a +% bottom area. +% +% However we only do this if the float doesn't span.\footnote{Extend?} +% \begin{macrocode} + \ifnum \this@area@span@number = \@ne +%<*trace> + \tr@ce{this@area,column:~ \this@area,~\the\curr@col@count} +%</trace> + \if b \this@area@type + \ifnum \this@area@col@number = \curr@col@count + \@failtrue + \fi + \fi + \fi + \if@fail +%<*progress> + \progress@failed{column~ \the\curr@col@count\space + contains~ footnotes~ and~ bottom~ floats} +%</progress> +%<*trace> + \tr@ce{Failed:~ column~ \the\curr@col@count\space + contains~ footnotes~ and~ bottom~ floats} +%</trace> + \global\curr@col@count\col@count + \fi + \fi +%<*trace> + \@tracepop{check@float@footnote@forbidden} +%</trace> +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\check@float@footnote@none} +% +% This is the implementation for |\check@some@constraints| if we +% don't care about mixing footnotes and bottom floats. The reason +% |\@empty| rather than |\relax| is used is that otherwise the +% |\ifx| test in the template would fail. +% \begin{macrocode} +\let\check@float@footnote@none\@empty +% \end{macrocode} +% \end{macro} +% +% +% +% +% +% +% \endinput +\endinput +% +% $Log: xo-place.dtx,v $ +% Revision 1.37 2000/08/11 07:14:28 latex3 +% added header +% +% Revision 1.36 2000/08/11 06:49:47 latex3 +% untabify +% +% Revision 1.35 2000/08/11 06:45:03 latex3 +% only partially tighten float constraints after passing a flush point +% +% Revision 1.34 2000/07/23 21:03:19 latex3 +% removed obsolete commentary +% +% Revision 1.33 2000/07/21 13:53:17 latex3 +% more renaming for float sequence class concept +% +% Revision 1.32 2000/07/18 21:06:36 latex3 +% introduced float sequence classes +% +% Revision 1.31 2000/07/12 17:24:53 latex3 +% more support for grids +% +% Revision 1.30 2000/07/10 21:00:57 latex3 +% support for grid typesetting +% +% Revision 1.29 2000/07/04 19:42:05 latex3 +% fix tracing for GRID stuff +% +% Revision 1.28 2000/07/01 15:57:25 latex3 +% use \update@this@area@columns +% integrate code to support grid design (first draft) +% +% Revision 1.27 2000/06/29 17:18:14 latex3 +% introduced \setup@this@area +% +% Revision 1.26 2000/06/26 15:03:40 latex3 +% making prototype for \pagesetup@float@area@sep +% +% Revision 1.25 2000/06/22 20:08:09 latex3 +% renamed some macros to get them more uniform +% +% Revision 1.24 2000/06/22 11:01:24 latex3 +% When substracting heights from columns do this for the columns spanned +% by the area. Don't use the span number from the float (in the future +% this might be smaller than the span number of the area) +% +% Revision 1.23 2000/06/19 21:38:04 latex3 +% fixed flush point handling when deferring +% +% Revision 1.22 2000/06/18 19:03:53 latex3 +% added "Checking bottom float footnote constraints" from xo-page +% +% Revision 1.21 2000/06/16 11:20:15 latex3 +% rename \construct@and@test@col@height to \construct@and@test@col@ht +% rename \construct@and@test@col@heights to \construct@and@test@col@hts +% rename \cl@height1 to \@col@ht@1 (etc) +% +% Revision 1.20 2000/06/16 11:06:37 latex3 +% support float-callout-span-constraint +% +% Revision 1.19 2000/06/16 07:49:49 latex3 +% improve progress info +% +% Revision 1.18 2000/06/15 17:49:02 latex3 +% moved macros from xo-page into here since they deal with placement +% +% Revision 1.17 2000/06/15 15:23:32 latex3 +% implemented new semantics for area names +% +% Revision 1.16 2000/06/13 20:48:18 latex3 +% docu update +% +% Revision 1.15 2000/06/06 12:50:40 latex3 +% before attempting fuzzy flushpoints +% +% Revision 1.14 2000/05/03 18:57:56 latex3 +% provide \construct@and@test@col@heights subroutine +% +% fix problem that deferred floats would not stop other floats going +% into earlier areas +% +% Revision 1.13 2000/03/31 17:08:50 latex3 +% avoid using up too much input stack by using tail recursion in +% strategic places (tmp fix) +% +% Revision 1.12 2000/03/26 21:04:03 latex3 +% some renaming of macros +% +% Revision 1.11 2000/03/24 15:34:27 latex3 +% version that starts supporting spans (still a hack yet) +% +% Revision 1.10 2000/03/22 15:52:37 latex3 +% some normalisations of names +% first go at spans (tmp version) +% +% Revision 1.9 2000/03/17 20:23:11 latex3 +% more fixes to flushing (looks good now) +% +% Revision 1.8 2000/03/16 10:28:29 latex3 +% partial and full flush working for the first time +% +% Revision 1.7 2000/03/05 19:31:56 latex3 +% some renaming +% extend to multiple columns (6 max right now) +% fix defer logic: when flushseen don't defer immediately +% +% Revision 1.6 2000/02/27 15:12:45 david +% *** empty log message *** +% +% Revision 1.5 2000/02/27 11:27:45 david +% first attempt at flush floats +% +% Revision 1.4 2000/02/26 18:24:21 david +% renaming, and using \initialise@areas +% +% Revision 1.3 2000/02/16 13:40:09 latex3 +% added 3col support +% +% Revision 1.2 2000/02/16 10:10:43 latex3 +% added documentation +% added test for float area size after adding float +% +% Revision 1.1 2000/02/13 22:27:39 latex3 +% Initial revision +% diff --git a/Master/texmf-dist/source/latex3/xor/xo-trace.dtx b/Master/texmf-dist/source/latex3/xor/xo-trace.dtx new file mode 100644 index 00000000000..435994f1682 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo-trace.dtx @@ -0,0 +1,140 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xo-trace.dtx,v 1.9 2000/08/11 07:14:29 latex3 Exp $ +% \end{macrocode} +% +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% \begin{macrocode} +\def\showmarks{ + \toks@\expandafter{\topmark}\typeout{topmark:\the\toks@} + \toks@\expandafter{\firstmark}\typeout{firstmark:\the\toks@} + \toks@\expandafter{\botmark}\typeout{botmark:\the\toks@} +} +% \end{macrocode} +% +% \begin{macrocode} +\def\showfloatlists{{ + \let\@elt\@empty + \typeout{free:~\@freelist} + \typeout{active:~\@activelist} + \typeout{mvl:~\@mvllist} + \typeout{defer:~\area@ddd} + \typeout{assigned:} + \showfloatarea{t13} + \showfloatarea{t12} + \showfloatarea{t22} + \showfloatarea{t11} + \showfloatarea{t21} + \showfloatarea{t31} + \showfloatarea{b11} + \showfloatarea{b21} + \showfloatarea{b31} + \edef\@tempa{currbox\expandafter\strip@prefix\meaning\@currbox>\space + this@float\expandafter\strip@prefix\meaning\this@float@box>} + \show\@tempa}} + +\def\showfloatarea#1{ + \@ifundefined{area@#1}{} + {\expandafter + \ifx\csname area@#1\endcsname\@empty + \else + \typeout{~\space\space #1:~\csname area@#1\endcsname} + \fi + } +} +% \end{macrocode} +% +% \begin{macrocode} +%<*trace> +\def \@tracemessage #1{% + \begingroup\let\@elt\space\typeout{:~\tf@indent~#1}\endgroup} +% \end{macrocode} +% +% \begin{macrocode} +\let\tf@indent\@empty +% \end{macrocode} +% +% \begin{macrocode} +\def\@tracepush#1{% + \tr@ce{entering~#1} + \xdef\tf@indent{-\tf@indent}} +% \end{macrocode} +% +% \begin{macrocode} +\def\@tracepop#1{% + \tr@ce{leaving~#1} + \xdef\tf@indent{\expandafter\@gobble\tf@indent}} +% \end{macrocode} +% +% \begin{macrocode} +\def \tracefloats{\global\let \tr@ce \@tracemessage} +% \end{macrocode} +% +% \begin{macrocode} +\def \notrace {\global\let \tr@ce \@gobble} +%\notrace +% \end{macrocode} +% +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +\def\traceonly#1{ + \notrace + \def\@trace@command{#1} + \gdef\@tracepush##1{ + \def\@trace@this{##1} + \ifx\@trace@this\@trace@command + \global\let\@this@tf@indent\tf@indent + \tracefloats + \tr@ce{entering~##1} + \fi + \xdef\tf@indent{-\tf@indent}} + \def\@tracepop##1{ + \tr@ce{leaving~##1} + \xdef\tf@indent{\expandafter\@gobble\tf@indent} + \ifx\@this@tf@indent\tf@indent + \global\let\@this@tf@indent\relax + \notrace + \fi} +} +% \end{macrocode} +% +% \begin{macrocode} +\tracefloats +% \end{macrocode} +% +% \begin{macrocode} +\def \@traceval #1{\tr@ce{\string #1~=~\the #1}} +%</trace> +%<-trace>\let\tr@ce\@gobble +% \end{macrocode} +% +% \begin{macrocode} +%<*progress> +\def \progress #1{\message{#1}} +\def \progress@separator{ + \progress{=============================== + ========================================^^J}} +\def \progress@nl #1{\progress{~ #1^^J}} +\def \progress@failed #1{\progress@nl{ ->~ failed:~ #1}} +%</progress> +% \end{macrocode} diff --git a/Master/texmf-dist/source/latex3/xor/xo.ins b/Master/texmf-dist/source/latex3/xor/xo.ins new file mode 100644 index 00000000000..be726b76dfa --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xo.ins @@ -0,0 +1,40 @@ +% +% $Id: xo.ins,v 1.4 2000/08/05 09:43:49 latex3 Exp $ + +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble + +Not for distribution + +(C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +All rights reserved. + +Not for general distribution. In its present form it is not allowed +to put this package onto CD or an archive without consulting the +the authors. +\endpreamble + + + +\generate{% + \file{xmarks.sty}{\from{xmarks.dtx}{package}} + \file{xo-alloc.sty}{\from{xo-alloc.dtx}{package}} + \file{xo-capt.sty}{\from{xo-capt.dtx}{package}} + \file{xo-final.sty}{\from{xo-final.dtx}{package}} + \file{xo-float.sty}{\from{xo-float.dtx}{package}} + \file{xo-grid.sty}{\from{xo-grid.dtx}{package}} + \file{xo-here.sty}{\from{xo-here.dtx}{package}} + \file{xo-new.sty}{\from{xo-new.dtx}{package}} + \file{xo-or.sty}{\from{xo-or.dtx}{package}} + \file{xo-page.sty}{\from{xo-page.dtx}{package}} + \file{xo-place.sty}{\from{xo-place.dtx}{package}} + \file{xo-trace.sty}{\from{xo-trace.dtx}{package,trace}} + \file{xoutput.sty}{\from{xoutput.dtx}{package}} +} + +\endbatchfile + +% \file{xo-implement.sty}{\from{xo-implement-generic-algorithm.dtx}{package}} diff --git a/Master/texmf-dist/source/latex3/xor/xoprogress.ins b/Master/texmf-dist/source/latex3/xor/xoprogress.ins new file mode 100644 index 00000000000..307853273dd --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xoprogress.ins @@ -0,0 +1,40 @@ +% +% $Id: xoprogress.ins,v 1.3 2000/08/04 15:54:51 latex3 Exp $ + +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble + +Not for distribution + +(C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +All rights reserved. + +Not for general distribution. In its present form it is not allowed +to put this package onto CD or an archive without consulting the +the authors. +\endpreamble + + + +\generate{% + \file{xmarks.sty}{\from{xmarks.dtx}{package}} + \file{xo-alloc.sty}{\from{xo-alloc.dtx}{package,progress}} + \file{xo-capt.sty}{\from{xo-capt.dtx}{package,progress}} + \file{xo-final.sty}{\from{xo-final.dtx}{package,progress}} + \file{xo-float.sty}{\from{xo-float.dtx}{package,progress}} + \file{xo-grid.sty}{\from{xo-grid.dtx}{package,progress}} + \file{xo-here.sty}{\from{xo-here.dtx}{package,progress}} + \file{xo-new.sty}{\from{xo-new.dtx}{package,progress}} + \file{xo-or.sty}{\from{xo-or.dtx}{package,progress}} + \file{xo-page.sty}{\from{xo-page.dtx}{package,progress}} + \file{xo-place.sty}{\from{xo-place.dtx}{package,progress}} + \file{xo-trace.sty}{\from{xo-trace.dtx}{package,progress,trace}} + \file{xoutput.sty}{\from{xoutput.dtx}{package,progress}} +} + +\endbatchfile + +% \file{xo-implement.sty}{\from{xo-implement-generic-algorithm.dtx}{package,progress}} diff --git a/Master/texmf-dist/source/latex3/xor/xotrace.ins b/Master/texmf-dist/source/latex3/xor/xotrace.ins new file mode 100644 index 00000000000..7c5f971dcce --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xotrace.ins @@ -0,0 +1,40 @@ +% +% $Id: xotrace.ins,v 1.4 2000/08/04 15:47:48 latex3 Exp $ + +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble + +Not for distribution + +(C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +All rights reserved. + +Not for general distribution. In its present form it is not allowed +to put this package onto CD or an archive without consulting the +the authors. +\endpreamble + + + +\generate{% + \file{xmarks.sty}{\from{xmarks.dtx}{package,trace}} + \file{xo-alloc.sty}{\from{xo-alloc.dtx}{package,trace}} + \file{xo-capt.sty}{\from{xo-capt.dtx}{package,trace}} + \file{xo-final.sty}{\from{xo-final.dtx}{package,trace}} + \file{xo-float.sty}{\from{xo-float.dtx}{package,trace}} + \file{xo-grid.sty}{\from{xo-grid.dtx}{package,trace}} + \file{xo-here.sty}{\from{xo-here.dtx}{package,trace}} + \file{xo-new.sty}{\from{xo-new.dtx}{package,trace}} + \file{xo-or.sty}{\from{xo-or.dtx}{package,trace}} + \file{xo-page.sty}{\from{xo-page.dtx}{package,trace}} + \file{xo-place.sty}{\from{xo-place.dtx}{package,trace}} + \file{xo-trace.sty}{\from{xo-trace.dtx}{package,trace}} + \file{xoutput.sty}{\from{xoutput.dtx}{package,trace}} +} + +\endbatchfile + +% \file{xo-implement.sty}{\from{xo-implement-generic-algorithm.dtx}{package,trace}} diff --git a/Master/texmf-dist/source/latex3/xor/xoutput.drv b/Master/texmf-dist/source/latex3/xor/xoutput.drv new file mode 100644 index 00000000000..ee33688cd25 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xoutput.drv @@ -0,0 +1,144 @@ +\def\rcsdata#1: #2,v #3${ + \def\rcsdata{#2 #3}} +\rcsdata$Id: xoutput.drv,v 1.11 2000/08/04 16:42:11 latex3 Exp $ + +\documentclass[a4paper]{ltxdoc} + +\usepackage{hyperref} + +%\usepackage{trace,xoutput} + +\CodelineIndex +\EnableCrossrefs + +\setcounter{IndexColumns}{2} + +\DoNotIndex{\@elt,\@ne,\@tracepush,\@tracepop,\@empty,\@namedef} +\DoNotIndex{\@spaces} +\DoNotIndex{\advance,\aftergroup,\begingroup,\bgroup,\box,\chardef,\copy,\count,\countdef} +\DoNotIndex{\count@,\csname,\def,\do,\dimen,\dimendef\endgroup,\egroup,\else,\endcsname,\expandafter} +\DoNotIndex{\fi,\gdef,\global,\if,\ifdim,\ifeof,\ifnum,\iftrue,\ifx} +\DoNotIndex{\immediate,\let,\long,\m@ne,\mathchardef,\meaning,\message,\multiply} +\DoNotIndex{\noexpand,\read,\relax,\repeat,\setbox,\space,\string\the} +\DoNotIndex{\toks,\tr@ce,\tw@,\unskip,\unvbox,\unvcopy,\vadjust} +\DoNotIndex{\value,\vbox,\voidb@x,\vrule,\vskip,\vss,\wlog,\write,\z@} +\DoNotIndex{\hbox,\hrule,\ht,\dp,\wd,\ifinner} +\DoNotIndex{\RequirePackage,\typeout,\xdef,\tracingall} + + +\begin{document} + +\title{A new output routine for \LaTeX\thanks{\rcsdata}} +\author{\copyright\ Frank Mittelbach, David Carlisle and Chris Rowley} +\date{Started in 1996--7; first real implementation in Feb 2000 +} + +\maketitle +\tableofcontents + + +\iffalse + +\section{What has been done} + +To get a rough estimate of the work involved (and make me feel good) +look at the rcs change lines per file of the output routine +(as of June 21 2000) using: +\begin{verbatim} + for f in xo*dtx xo*tex ; do rlog $f ; done | \ + awk -f get-changes.awk |sort +\end{verbatim} + +\begin{scriptsize} +\begin{verbatim} +author: # changes # total lines # added lines # plus lines # minus lines +car2; 4 1.84332% 1907 7.21065% 773 7.97977% 1340 7.41684% -567 6.76611% +david; 51 23.5023% 3181 12.0278% 1935 19.9752% 2558 14.1584% -623 7.43437% +frank; 162 74.6544% 21359 80.7615% 6979 72.045% 14169 78.4248% +-7190 85.7995% +\end{verbatim} +\end{scriptsize} + +\fi + +\section{xoutput} +\DocInput{xoutput.dtx} + +\section{Output Routine Tracing} +\DocInput{xo-trace.dtx} + +\newpage +\section{Output Routines} +\DocInput{xo-or.dtx} + +\newpage +\section{Interfacing Here Points} +\DocInput{xo-here.dtx} + +\newpage +\section{Float Placement Algorithm} +\DocInput{xo-place.dtx} + +\newpage +\section{Page Makeup} +\DocInput{xo-final.dtx} + +\newpage +\section{Page Setup Templates} +\DocInput{xo-page.dtx} + +\newpage +\section{Float Environments} +\DocInput{xo-float.dtx} + +\section{Captions} +\DocInput{xo-capt.dtx} + +\section{Allocations} +\DocInput{xo-alloc.dtx} + +\section{Redefinitions for Grid Design} +\DocInput{xo-grid.dtx} + +\section{New stuff that needs merging (or cleanup)} +\DocInput{xo-new.dtx} + +\newpage + +\PrintIndex + +\typeout{=====================================================================} +\typeout{} +\typeout{To get proper index run the document using:} +\typeout{} +\typeout{latex xoutput.drv ; makeindex -s gind.ist xoutput ; latex xoutput.drv} +\typeout{} +\typeout{=====================================================================} + +\end{document} + +% $Log: xoutput.drv,v $ +% Revision 1.11 2000/08/04 16:42:11 latex3 +% *** empty log message *** +% +% Revision 1.10 2000/07/30 18:06:52 latex3 +% added xo-grid.dtx +% +% Revision 1.9 2000/06/15 09:34:37 latex3 +% use .dtx not .sty +% +% Revision 1.8 2000/04/21 19:09:14 latex3 +% added xo-here +% +% Revision 1.7 2000/04/07 07:29:56 latex3 +% added index +% +% Revision 1.6 2000/03/16 10:28:29 latex3 +% adding index +% +% Revision 1.5 2000/03/09 14:44:31 latex3 +% *** empty log message *** +% +% Revision 1.4 2000/03/05 19:42:59 latex3 +% new sections +% diff --git a/Master/texmf-dist/source/latex3/xor/xoutput.dtx b/Master/texmf-dist/source/latex3/xor/xoutput.dtx new file mode 100644 index 00000000000..6f0467022cc --- /dev/null +++ b/Master/texmf-dist/source/latex3/xor/xoutput.dtx @@ -0,0 +1,78 @@ +% \iffalse +%% +%% (C) Copyright 1999-2000 Frank Mittelbach, David Carlisle, Chris Rowley +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +% \fi +% + +% \begin{macrocode} +\def\@tempa#1: #2.dtx,v #3 #4 #5 #6 #7${ + \ProvidesPackage{#2}[#4 #3 #5 #6]} +\@tempa$Id: xoutput.dtx,v 1.13 2000/08/11 07:14:49 latex3 Exp $ +% \end{macrocode} +% +% \begin{macrocode} +\RequirePackage{ + ldcsetup, + template, + xmarks, + xparse, + xo-trace,xo-or, + xo-here, + xo-place,xo-page,xo-float,xo-capt,xo-final, + xo-alloc, + xo-new +} +% \end{macrocode} +% + + +% Ignore white space in this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% +% +% +% \endinput +\endinput +% +% $Log: xoutput.dtx,v $ +% Revision 1.13 2000/08/11 07:14:49 latex3 +% added header +% +% Revision 1.12 2000/07/18 21:05:43 latex3 +% removed initialisations +% +% Revision 1.11 2000/07/12 19:44:58 latex3 +% removed some commented out code +% +% Revision 1.10 2000/06/13 21:22:29 latex3 +% turned into a dtx file +% +% Revision 1.9 2000/04/21 19:06:01 latex3 +% removed old initialisation +% added xo-here +% +% Revision 1.8 2000/03/31 17:00:18 latex3 +% fixed rcs log +% +% Revision 1.7 2000/03/22 15:53:39 latex3 +% added xparse +% +% Revision 1.6 2000/02/26 18:26:26 david +% xo-alloc and xo-new added +% +% Revision 1.5 2000/02/13 21:58:07 latex3 +% oops, my rcs again (probably something that will only show up here +% but to ensure that everything is fine I add an \endinput) +% +% Revision 1.4 2000/02/13 21:33:05 latex3 +% added xo-place (float trial placement tests) +% diff --git a/Master/texmf-dist/source/latex3/xparse/ldcsetup.dtx b/Master/texmf-dist/source/latex3/xparse/ldcsetup.dtx new file mode 100644 index 00000000000..c280221b7e5 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xparse/ldcsetup.dtx @@ -0,0 +1,264 @@ +% \iffalse +%% +%% (C) Copyright 1999 Frank Mittelbach, Chris Rowley, David Carlisle +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{ldcsetup.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{ldcsetup} +%<driver>\ProvidesFile{ldcsetup.drv} +% \fi +% \ProvidesFile{ldcsetup.dtx} + [1999/09/10 v0.04 coding conventions and stuff] +% +% \iffalse +%<*driver> +\documentclass{ltxdoc} +\begin{document} +\DocInput{ldcsetup.dtx} +\end{document} +%</driver> +% \fi +% +% \CheckSum{249} +% +% \GetFileInfo{ldcsetup.dtx} +% +% \title{The \textsf{ldcsetup} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{DPC, FMi} +% \date{\filedate} +% \maketitle +% +% \begin{abstract} +% Basic code shared by several other packages currently under development. +% \end{abstract} +% +% \StopEventually{} +% +% \begin{macrocode} +%<*package> +% \end{macrocode} +% +% \begin{macrocode} +\RequirePackage{keyval,calc} +% \end{macrocode} +% +% \section{Ignoring White Space} +% Within a package, or in a document preamble, you can use +% |\IgnoreWhiteSpace| this makes white space ignored, and |@| +% a letter, and |~| a space character. It lasts until the end of the +% current package or preamble. +% +%% Puts an ignored space at the end of the line, so `|\ |' does the right +% thing. (Perhaps should instead just change catcode of |^^M|) +% \begin{macrocode} +\def\IgnoreWhiteSpace{% + \edef\@tempa{% + \catcode`\noexpand\~=\the\catcode`\~\relax + \catcode`\noexpand\ =\the\catcode`\ \relax + \catcode`\noexpand\^^I=\the\catcode`\^^I\relax + \catcode`\noexpand\@=\the\catcode`\@\relax + \endlinechar=\the\endlinechar\relax + }% + \ifx\@currname\@empty + \expandafter\AtBeginDocument\expandafter{\@tempa}% + \else + \expandafter\AtEndOfPackage\expandafter{\@tempa}% + \fi + \catcode`\~=10\relax + \catcode`\ =9\relax + \catcode`\^^I=9\relax + \makeatletter +% \endlinechar=\m@ne + \endlinechar=` % +} +% \end{macrocode} +% +% Do it for this package. +% \begin{macrocode} +\IgnoreWhiteSpace +% \end{macrocode} +% +% \section{KV fixes} +% Allow\footnote{Not needed now?} key names to start with |\|. +% \begin{macrocode} +\def\define@key#1#2{% + \@ifnextchar[ + {\KV@def{#1}{\string#2}} + {\@namedef{KV@#1@\string#2}####1}} +\def\setkeys#1#2{% + \def\KV@prefix{KV@#1@\expandafter\string}% + \KV@do#2,\relax,} +% \end{macrocode} +% +% Make KV |#| safe. +% \begin{macrocode} +% \end{macrocode} +% +% \begin{macrocode} +\newtoks\KV@toks +% \end{macrocode} +% +% \begin{macrocode} +\def\KV@@sp@c#1\@nil#2\relax#3{\KV@toks{#1}\edef#3{\the\KV@toks}} +% \end{macrocode} +% +% Generate error messages on missing `,'. +% +% More exactly if two `=' appear after a key generate an error. +% The current KV just silently ignores everything after the second `='. +% \begin{macrocode} +\def\KV@equal{=} +% \end{macrocode} +% +% \begin{macrocode} +\def\KV@split#1=#2=#3\relax{% + \KV@@sp@def\@tempa{#1}% + \def\@tempd{#3}% + \ifx\@tempa\@empty\else + \expandafter\let\expandafter\@tempc + \csname\KV@prefix\@tempa\endcsname + \ifx\@tempc\relax + \KV@error{\@tempa\space \expandafter\@gobbletwo\string\@undefined}\@eha + \else + \ifx\@tempd\@empty + \KV@default + \else + \KV@@sp@def\@tempb{#2}% + \ifx\@tempd\KV@equal + \expandafter\@tempc\expandafter{\@tempb}\relax + \else + \KV@error{Extra~=~ sign~ after~ `#1'}\KV@erry + \fi + \fi + \fi + \fi} +% \end{macrocode} +% +% \begin{macrocode} +\def\KV@erry{\expandafter\KV@errx\meaning\@tempd\relax ignored\MessageBreak + missing~comma~in~`\expandafter\strip@prefix\meaning\@tempb'~?} +% \end{macrocode} +% +% \begin{macrocode} +\def\KV@errx#1>#2==\relax{% + `#2' } +% \end{macrocode} +% +% \begin{macrocode} +\def\KV@default{% + \expandafter\let\expandafter\@tempb + \csname\KV@prefix\@tempa @default\endcsname + \ifx\@tempb\relax + \KV@error{No value specified for \@tempa}\@eha + \else + \@tempb\relax + \fi} +% \end{macrocode} +% +% \LaTeX\ style error message. +% \begin{macrocode} +\def\KV@error#1#2{\PackageError{keyval}{#1}{#2}} +% \end{macrocode} +% +% Instead of doing a full KV parse, and evaluating all the keys, +% you might want to parse a parameter list, even for undefined keys, +% removing spaces, splitting up the `,` and `=' and resolving cases +% where no value is supplied. This is used in |\DeclareGenericFunction| +% which \emph{defines} a set of keys via such a KV parse. +% +% A setting of |, key = value ,| will result in |\KV@elt{key}{value}| +% being added to the list, a seting of |, key ,| will result in +% |\KV@default@elt{key}| being added. At the end of the parse the list +% is executed. No keys are checked at this stage (so no csnames are used +% up) the two |\KV|\ldots|@elt| commands must be defined as appropriate. +% +% \begin{macrocode} +\def\KV@parse#1{ + \begingroup +% \end{macrocode} +% +% Locally fudge |\KV@@def| to just add to a token register +% rather than make a definition. +% \begin{macrocode} +\def\KV@@sp@c##1\@nil##2\relax##3{\addto@hook##3{{##1}}} +% \end{macrocode} +% +% Locally fudge |\KV@split| to just add to a token register +% rather than execute the code for the found keys. +% \begin{macrocode} +\def\KV@split##1=##2=##3\relax{% + \def\@tempd{##3}% + \expandafter\ifx\expandafter=\@firstofone##1=\else + \ifx\@tempd\@empty + \addto@hook\KV@toks\KV@default@elt + \KV@@sp@def\KV@toks{##1}% + \else + \ifx\@tempd\KV@equal + \addto@hook\KV@toks\KV@elt + \KV@@sp@def\KV@toks{##1}% + \KV@@sp@def\KV@toks{##2}% + \else + \KV@err{Extra `=' after `##1'}\@ehd + \fi + \fi + \fi} +% \end{macrocode} +% +% Initialise +% \begin{macrocode} + \KV@toks{} +% \end{macrocode} +% Do the parse +% \begin{macrocode} + \KV@do#1,\relax, +% \end{macrocode} +% Evaluate the token register outside the group. +% \begin{macrocode} + \expandafter + \endgroup + \the\KV@toks} +% \end{macrocode} +% +% \section{Calc fixes} +% +% Count Register assignments via calc. +% \begin{macrocode} +\let\SetInternalCounter\calc@assign@count +% \end{macrocode} +% +% +% \section{Misc code that is best collected in one place} +% +% This section will receive odd code that would be of potential use to +% other packages and should eventually made it to the kernel +% (perhaps). +% +% \begin{macro}{\UndeclareRobustCommand} +% Remove a robust command from memory if it isn't used any +% longer. Of course this doesn't free the hash table but at least +% the space gets reclaimed. +% \begin{macrocode} +\def\UndeclareRobustCommand#1{% + \global\let#1\undefined + \global\expandafter + \let\csname\expandafter\@gobble\string#1~\endcsname\undefined +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% \Finale +% diff --git a/Master/texmf-dist/source/latex3/xparse/xparse.dtx b/Master/texmf-dist/source/latex3/xparse/xparse.dtx new file mode 100644 index 00000000000..1bee47bb059 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xparse/xparse.dtx @@ -0,0 +1,1339 @@ +% \iffalse +%% +%% (C) Copyright 1999 Frank Mittelbach, Chris Rowley, David Carlisle +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{xparse.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{xparse} +%<driver>\ProvidesFile{xparse.drv} +% \fi +% \ProvidesFile{xparse.dtx} + [1999/09/10 v0.17 generic document command parser] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} + \usepackage{textcomp} +% \usepackage{ldcdoc} + \begin{document} + \DocInput{xparse.dtx} + \end{document} +%</driver> +% \fi +% +% \CheckSum{667} +% +% \GetFileInfo{xparse.dtx} +% +% \title{The \textsf{xparse} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{FMi, CAR, DPC} +% \date{\copyright~\filedate} +% \maketitle +% +% \begin{abstract} +% The interfaces described in this document are not meant to be final +% but only as a basis for discussion. Building productive applications +% using the current code is discouraged. +% \end{abstract} +% +% \section{Interface} +% +% This package implements high-level interface commands for class file +% writers which allows the separation of formatting commands +% (typically instances of so-called `templates') and their arguments +% from the signature of document-level commands. +% +% This works by declaration commands that provide a general +% specification method for the typical \LaTeX{} syntax, e.g., +% star-form, optional arguments, and mandatory arguments. A command +% (or environment) declared in this way parses the input according to +% its spec and presents its findings in a normalized way for further +% processing. +% +% \subsection{Argument spec} +% +% An argument specification is a list of letters each representing a +% type of argument, i.e., |m| is a mandatory argument (surrounded by +% braces), |o| an optional argument (surrounded by brackets if +% present), and |s| represents a star (which might be present or +% not).\footnote{Other argument types such as \texttt{c} for picture +% coordinates could be integrated in principle --- the last prototype +% now contains support for\texttt{c}.} Thus the argument +% spec for headings as implemented by |\@startsection| in standard +% \LaTeX{} would be represented by the three letters |som|. +% +% With the new proof of concept implementation there is also +% |O{default}| which acts like |o| which also scans for an optional +% argument but allows to specify a default value if the optional +% argument is not present. I.e., it can be used to turn mandatory +% arguments of a template (that is those that do not check for +% |\NoValue|) into optional ones by supplying a default on the +% document command level. +% +% We also have |C{{x-default}{y-default}}| to allow for optional +% coordinate pairs which is, for example, needed to provide something +% like the picture environment in current \LaTeX. +% +% \subsection{Parsing results} +% +% To normalise the result of parsing the input according to an +% argument specification it is important to uniquely identify all +% arguments found. For this reason each parsing operation initiated by +% one of the argument spec letters will result in an identifiable +% output as follows: +% \begin{description} +% \item[m] will return the parsed argument surrounded by a brace pair, +% i.e., will normally be the identity; +% \item[o] will return the parsed argument surrounded by a brace pair +% if present. Otherwise it will return the token |\NoValue|; +% \item[O\textbraceleft default\textbraceright] will return the parsed +% argument surrounded by a brace pair +% if present. Otherwise it will return the |{default}| as specified above. +% \item[s] will return either the token |\BooleanTrue| or +% |\BooleanFalse| depending on whether or not a star was parsed. +% \item[c] will parse the syntax |(|\meta{x}|,|\meta{y}|)|, i.e., a +% coordinate pair and will return |{{|\meta{x}|}{|\meta{y}|}}| as +% the result. If no open parentheses is scanned an error is signalled. +% \item[C\textbraceleft\textbraceleft x-default\textbraceright\textbraceleft +% y-default\textbraceright\textbraceright] behaves like |c|, i.e., parses a +% coordinate pair if present. If the coordinate pair is missing it +% returns the default values instead. +% \end{description} +% For example, given the spec |soomO{default}| the input |*[Foo]{Bar}| would be +% parsed as |\BooleanTrue{Foo}\NoValue{Bar}{default}|. In other words +% there will be always exactly the same number of brace groups or +% tokens as the number of letters in the argument spec. +% +% \subsection{Applying the parsing results} +% +% Since the result of the parsing is a well defined number of tokens or +% brace groups it is easy to pass them on in any order to any +% processing function. To this end the tokens or brace groups are +% associated with the standard argument specifiers in \TeX{} macros, +% i.e., |#1|, |#2|, and so forth. This limits the argument +% specification to a maximum number of 9 letters, but for practical +% applications this should be sufficient. +% +% \subsection{The class designer interface} +% +% This package provides two commands for declaring commands +% and environments to be used within the document body. +% +% \DescribeMacro\DeclareDocumentCommand +% The |\DeclareDocumentCommand| declaration takes three arguments. The +% first argument is the name of the command to be declared, the second +% is the argument specification in the syntax described above, and the +% third is the action to be carried out once the arguments are +% parsed. Within the third argument |#1|, |#2|, etc.\ denote the +% result of the parsing, e.g., +%\begin{verbatim} +% \DeclareDocumentCommand{\chapter}{som} +% { \IfBooleanTF {#1} +% { \typesetnormalchapter {#2}{#3} } +% { \typesetstarchapter {#3} } +% } +%\end{verbatim} +% would be a way to define a |\chapter| command which would +% essentially behave like the current \LaTeX{} command (except that it +% would accept an optional argument even when a |*| was parsed). The +% |\typesetnormalchapter| could test its first argument for being +% |\NoValue| to see if an optional argument was present. +% +% Of course something like the |\IfNoValueTF| test could also be +% placed inside a function that would process all three arguments, thus +% using the templates and their instances as provided by the +% \texttt{template} package such a declaration would probably look +% more like the following example: +%\begin{verbatim} +% \DeclareDocumentCommand{\chapter}{som} +% { \UseInstance {head} {A-head-main} {#1} {#2} {#3} } +%\end{verbatim} +% +% Using the |\DeclareDocumentCommand| interface it is easy to modify +% the document-level syntax while still applying the same +% layout-generating functions, e.g., a class that would not support +% optional arguments or star forms for the heading commands could +% define |\chapter| like this: +%\begin{verbatim} +% \DeclareDocumentCommand{\chapter}{m} +% { \UseInstance {head} {A-head-main} \BooleanFalse \NoValue {#1} } +%\end{verbatim} +% while a class that would allow for an additional optional argument +% (for whatever reason) could define it like that: +%\begin{verbatim} +% \DeclareDocumentCommand{\chapter}{somo} +% { \doSomethingWithTheExtraOptionalArg {#4} +% \UseInstance {head} {A-head-main} {#1} {#2} {#3} } +%\end{verbatim} +% +% Commands declared in this way are automatically robust (in David's +% implementation). +% +% \DescribeMacro\DeclareDocumentEnvironment +% The |\DeclareDocumentEnvironment| declaration is similar to +% |\DeclareDocumentCommand| except that it takes four arguments: the +% first being the environment name (without a backslash), the second +% again the argument-spec, and the third and forth are the actions +% taken at start end end of the environment. The parsed arguments are +% available to both the start and the finish as |#1|, |#2|, +% etc.\footnote{It is wishful thinking that the args can be made available +% to the end of the environment. In the current implementation this +% was buggy and has been taken out again below.} +% +% +% \subsubsection{Comparing tokens in a quarky way} +% +% Something like |\NoValue| would perhaps be best implemented as a +% ltx3 quark, i.e. a token which expands to itself as this is +% can be easily tested even if hidden inside a macro. The unfortunate +% side effect however is that it will result in a tight loop if it ever +% gets executed by mistake. +% +% \DescribeMacro\NoValue +% For this reason |\NoValue| is defined to expand to the string +% |-NoValue-| which would get typeset if ever executed thus clearly +% indicating the type of error the writer made. +% +% However this makes testing for this token slightly complicated as in +% that case the test +%\begin{verbatim} +% \def\seen{#1} +% \def\containsNoValue{\NoValue} +% \ifx\seen\containsNoValue +%\end{verbatim} +% will be true if |#1| was |\NoValue| but false if if |#1| itself +% contains a macro which contains |\NoValue|; a case that happens +% unfortunately very often in practice. Using unguarded |\edef| to +% define |\seen| is out of question as |#1| typically is either +% |\NoValue| or arbitrary user input (which is likely to die horribly +% even in a |\protected@edef|. +% +% \DescribeMacro\IfSomethingTF +% \DescribeMacro\IfSomethingT +% \DescribeMacro\IfSomethingF +% Therefore the |\IfSomethingTF| test uses a slower recursive +% procedure: it tests if |#1| and |#2| are equal. If they are testing +% stops and the true-case (argument |#3|) will be executed. If not, it +% expands the first token of |#2| and checks if the resulting +% token-list is identical to |#2| (this would happen if this first +% token is unexpandable or |#2| is empty). In the latter case testing +% terminates and the false-case (argument |#4|) will be +% executed. However if the token-list created this way differs from +% |#2| the macro recurses using this token-list in place of |#2|. +% +% \DescribeMacro\IfNoValueTF +% \DescribeMacro\IfNoValueT +% \DescribeMacro\IfNoValueF +% \DescribeMacro\IfValueTF +% \DescribeMacro\IfValueT +% \DescribeMacro\IfValueF +% The test |\IfNoValueTF| is implemented as an application of +% |\IfSomethingTF|, i.e., +%\begin{verbatim} +% \def\IfNoValueTF{\IfSomethingTF\NoValue} +%\end{verbatim} +% where the three arguments (test token, true and false case) are +% picked up by |\IfSomethingTF|. Similar tests for other quark-like +% tokens could be defined similarly. |\IfValueTF| is the same test +% with the true/false case exchanged. +% +% +% \subsection{Some comments on the need for the \texttt{O} specifier} +% +% With |\newcommand| there is the possibility of specifying a default +% for an optional argument which is stored away in a more or less +% efficient manner. For example below is the old definition of +% |\linebreak| as can be found in the \LaTeX2e kernel: +%\begin{verbatim} +%\def\linebreak{\@testopt{\@no@lnbk-}4} +%\def\@no@lnbk #1[#2]{% +% \ifvmode +% \@nolnerr +% \else +% \@tempskipa\lastskip +% \unskip +% \penalty #1\@getpen{#2}% +% \ifdim\@tempskipa>\z@ +% \hskip\@tempskipa +% \ignorespaces +% \fi +% \fi} +%\end{verbatim} +% Ignoring for the moment that the above is slightly optimised an +% expansion of this code under |\tracingall| will result in about 90 +% lines of tracing output. +% If we reimplement this using |\DeclarDocumentCommand\linebreak{o}| +% we have to use |\IfNoValueTF| to find out if an argument was present +% which (because of the somewhat slow expansion of |\IfSomethingTF|) +% results in about twice as much of tracing lines. In contrast using +% |O{4}| as below we end up with 110 lines, which seems roughly the +% price we have to pay for the extra generality available (though this +% could perhaps even be reduced by a better implementation of the +% parsing machine as originally done by David, before i talked him +% into adding support for arguments in the end code of an environment). +% +%\begin{verbatim} +%\DeclareDocumentCommand\linebreak { O{4} } +% { +% \ifvmode +% \@nolnerr +% \else +% \@tempskipa\lastskip +% \unskip +% % \IfNoValueTF{#1} +% % {\break} +% % {\penalty -\@getpen{#1}} +% \penalty -\@getpen{#1} +% \ifdim\@tempskipa>\z@ +% \hskip\@tempskipa +% \ignorespaces +% \fi +% \fi +% } +%\end{verbatim} +% +% \subsubsection{A boolean data type} +% +% \DescribeMacro\BooleanTrue +% \DescribeMacro\BooleanFalse +% The parsing result for a star etc is presented as the token +% |\BooleanTrue| or |\BooleanFalse| respectively! +% +% \DescribeMacro\IfBooleanTF +% \DescribeMacro\IfBooleanT +% \DescribeMacro\IfBooleanF +% To test for these values the macro |\IfBooleanTF| can be used. It +% expects as its first argument either |\BooleanTrue| or +% |\BooleanFalse| and executes its second or third argument depending +% on this value. |\IfBooleanT| and |\IfBooleanF| are obvious +% shortcuts. +% +% At one point in time i thought that one can represent everything +% using |\NoValue|, e.g., for the star case either return |*| or +% |\NoValue|. However, this slows down processing of commands like +% |\\*| considerably since they would then have to use the slow +% |\IfSomethingTF| internally instead of a fast two-way switch. So now +% this data type is back in. +% +% \subsection{A somewhat complicated example} +% +% This example reimplements the |\makebox| and |\framebox| interface +% of \LaTeX{} both of which are unfortunately quite overloaded +% syntactically. For this reason the example isn't meant to show good +% coding practice but to show the power of the interface even though +% applied in a somewhat bad way. +% +% |\makebox| and |\framebox| support the following different document +% syntax forms: +% \begin{itemize} +% \item +% |\makebox{A}|: only a single mandatory argument. +% +% \item +% |\makebox[20pt]{B}|: one optional argument specify the box width. +% +% +% \item +% |\makebox[30pt][r]{C}|: two optional arguments the second specifying +% the text position within the box being made (l,c,r being allowed +% with c being the default). +% +% \item +% |\makebox(20,30){D}|: within picture mode the width is specified not +% as an optional argument in brackets but as a coordinate pair. +% +% \item +% |\makebox(0,0)[lt]{E}|: in that case an optional argument following +% coordinate pair denotes the placement within the box which can have +% different values compared to case C above. +% \end{itemize} +% +% To cater for this overloaded structure we can define |\makebox| to +% be something like the following: +%\begin{verbatim} +%\DeclareDocumentCommand \makebox { C{\NoValue} o O{c} m} +% { \IfNoValueTF{#1} +% { \ltx@maketextbox{#2}{#3}{#4} } +% { \ltx@makepicbox #1 {#2}{#4} } } +%\end{verbatim} +% In other words: if we do not see a coordinate pair first (i.e., +% first argument is |\NoValue| then we expect up to two optional +% arguments (the width of the box or |\NoValue| if not given and the +% placement specifier with a default of |c| if not given) and one +% mandatory one which is the text. In that case we pass argument 2 to +% 4 to an internal function |\ltx@maketextbox| which builds the text +% box. +% +% Otherwise, if the first argument is a coordinate pair we parse an +% optional argument denoting the placement specifier. Since +% \texttt{xparse} doesn't support variant syntax we actually parse for +% another optional argument (which has no meaning in that case and is +% in fact ignored if present) followed by a mandatory one containing +% the box text. In that case we pass the coordinate pair (|#1|), the +% specifier (|#2|), and the text (|#4|) to the function +% |\ltx@makepicbox| which builds the picture box. Note the special +% handling of the coordinatesD: which are passed without surrounding +% braces to |\ltx@makepicbox|: since the coordinate argument looks +% like |{x-val}{y-val}| the receiving function |\ltx@makepicbox| gets +% the |x-val| as argument one and the |y-val| as argument two. +% +% A definition for |\framebox| would look more or less identical +% except that we would need to pass the arguments to slightly +% different internal functions. The alternative is to give the +% internal functions an extra argument that controls whether or not a +% frame is bying built. +% +% \begin{macro}{\ltx@makepicbox} +% So here is a possible implementation of |\ltx@makepicbox| that +% builds a picture box with or without frame. It takes the following +% mandatory arguments: +% \begin{enumerate} +% \item x-part of coordinate +% \item y-part of coordinate +% \item placement specifier, e.g., |lt| or |\NoValue| +% \item text of box +% \item the token |\frame| (if a frame should surround the box) or the +% token |\@firstofone| --- not pretty i agree +% \end{enumerate} +%\begin{verbatim} +%\def\ltx@makepicbox#1#2#3#4#5 +% { +% #5{ +% \vbox to#2\unitlength +% {\let\mb@b\vss \let\mb@l\hss\let\mb@r\hss +% \let\mb@t\vss +% \IfNoValueF{#3} +% { +% \@tfor\reserved@a :=#3\do{ +% \if s\reserved@a +% \let\mb@l\relax\let\mb@r\relax +% \else +% \expandafter\let\csname mb@\reserved@a\endcsname\relax +% \fi}% +% } +% \mb@t +% \hb@xt@ #1\unitlength{\mb@l #4\mb@r} +% \mb@b +% \kern\z@} +% } +% } +%\end{verbatim} +% \end{macro} +% +% +% +% \begin{macro}{\ltx@maketextbox} +% For the text case the internal function could take the following +% mandatory arguments: +% \begin{enumerate} +% \item width of the box or |\NoValue| (denoting to build the box at +% natural width) +% \item placement specifier, e.g., |l|. (No test for |\NoValue| being undertaken) +% \item text of box +% \item the token |\fbox| (if a frame should surround the box) or the +% token |\mbox| +% \end{enumerate} +% The actual code is taken straight from the current \LaTeX{} kernel +% and looks kind of scary. +%\begin{verbatim} +%\def\ltx@maketextbox#1#2#3#4 +% { +% \IfNoValueTF{#1} +% {#4{#3}} +% { +% \leavevmode +% \@begin@tempboxa\hbox{#3} +% \setlength\@tempdima{#1} +% \ifx#4\fbox +% \setbox\@tempboxa\hb@xt@\@tempdima +% {\kern\fboxsep\csname bm@#2\endcsname\kern\fboxsep} +% \@frameb@x{\kern-\fboxrule} +% \else +% \hb@xt@\@tempdima{\csname bm@#2\endcsname} +% \fi +% \@end@tempboxa +% } +% } +%\end{verbatim} +% \end{macro} +% +% \begin{macro}{\makebox} +% \begin{macro}{\framebox} +% Given the above internal functions the declarations of |\makebox| +% and |\framebox| would then look like this: +%\begin{verbatim} +%\DeclareDocumentCommand \makebox { C{\NoValue} o O{c} m} +% { \IfNoValueTF{#1} +% { \ltx@maketextbox{#2}{#3}{#4}\mbox } +% { \ltx@makepicbox #1 {#2}{#4}\@firstofone } } +% +%\DeclareDocumentCommand \framebox { C{\NoValue} o O{c} m} +% { \IfNoValueTF{#1} +% { \ltx@maketextbox{#2}{#3}{#4}\fbox } +% { \ltx@makepicbox #1 {#2}{#4}\frame } } +%\end{verbatim} +% \end{macro} +% \end{macro} +% +% +% \StopEventually{} +% +% \section{Implementation} +% +% The implementation section currently contains several trial +% implementations and updates. This final version will probably look +% quite differently again. +% +% Set up certain defaults including to ignore white space +% within the body of this package. +% \begin{macrocode} +%<*package> +\RequirePackage{ldcsetup} +\IgnoreWhiteSpace +% \end{macrocode} +% +% + +% \subsection{The Mittelbach/Rowley prove-of-concept +% implementation for the parsing} +% +% \begin{macro}{\DeclareDocumentCommand} +% \begin{macrocode} +%<*obsolete> +\def\DeclareDocumentCommand #1 #2 { +% \parse@countargs {#2} % sets \@tempc % Not implemented yet + \def\parse@csname{#1} + \def\parse@spec{#2} + \afterassignment \declare@dt@ + \toks@ +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\declare@dt@} +% \begin{macrocode} +\def \declare@dt@ { + \expandafter \edef \parse@csname + { \noexpand \parse@something + { \parse@spec } + { \the\toks@ } + % { \@tempc } + } +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareDocumentEnvironment} +% \begin{macrocode} +\long\def\DeclareDocumentEnvironment #1 #2 { +% \parse@countargs {#2} % sets \@tempc % Not implemented yet + \def\parse@csname{#1} + \def\parse@spec{#2} + \afterassignment \declare@de@ + \toks@ +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\declare@de@} +% \begin{macrocode} +\def \declare@de@ { + \expandafter \edef \csname \parse@csname \endcsname + { \begingroup + \noexpand \parse@something + { \parse@spec } + { \the\toks@ } + % { \@tempc } + } + \afterassignment \declare@dee@ + \toks@ +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\declare@dee@} +% \begin{macrocode} +\def \declare@dee@ { + \expandafter \edef \csname end\parse@csname \endcsname + { \noexpand \parse@apply + { \the\toks@ } + \noexpand \parse@results + \endgroup + } +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\parse@apply} +% \begin{macrocode} +\def\parse@apply #1 { + \renewcommand \parse@tempa [\the\parse@cnt] {#1} + \expandafter \parse@tempa % #2 implicit +} +\let\parse@tempa\@empty % or \renew... might bulk the first time +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\parse@something} +% \begin{macrocode} +%% CCC here and elsewhere there are some suggestions for +% not counting args at run-time +\def \parse@something #1 #2 { % #3 + \parse@body {#2} + % \parse@cnt #3 + \parse@cnt \m@ne % REMOVE + \parse@args #1x \parse@args {} +} +% \end{macrocode} +% +% \begin{macrocode} +\newcount\parse@cnt +\newtoks\parse@body +% \end{macrocode} +% +% \begin{macrocode} +\def\parse@args #1 #2\parse@args #3 { + \advance \parse@cnt \@ne % REMOVE + \csname parse@#1 \endcsname {#2}{#3} +} +% \end{macrocode} +% +% \begin{macrocode} +\def \parse@s #1 #2 { + \@ifstar + { \parse@args #1 \parse@args { #2 \BooleanTrue } } + { \parse@args #1 \parse@args { #2 \BooleanFalse } } +} +% \end{macrocode} +% +% \begin{macrocode} +\def \parse@m #1 #2 #3 { + \parse@args #1 \parse@args { #2 {#3} } +} +% \end{macrocode} +% +% \begin{macrocode} +\def \parse@x #1 #2 { + \def \parse@results {#2} % for environment +% \def \parse@tempa { +% \renewcommand \parse@tempb [\the\parse@cnt] +% } +% \expandafter \parse@tempa \expandafter { \the \parse@body } +% \parse@tempb #2 + \expandafter \parse@apply \expandafter { \the \parse@body } + \parse@results % \parse@apply expands this! +} +% \end{macrocode} +% +% \begin{macrocode} +\def \parse@o #1 #2 { + \@ifnextchar [ + { \parse@o@ {#1}{#2} } + { \parse@args #1 \parse@args { #2 \NoValue } } +} +% \end{macrocode} +% +% \begin{macrocode} +\def \parse@o@ #1 #2 [#3] { + \parse@args #1 \parse@args { #2 {#3} } +} +%</obsolete> +% \end{macrocode} +% \end{macro} +% +% +% \subsection{The Carlisle implementation for the parsing} +% +% Not implemented in this version is |\DeclareDocumentEnvironment| +% (exercise for the reader).\footnote{Exercise now completed by DPC :-) +% (required re-implementing argument grabbers to grab to a toks +% register rather that into a brace group in the input stream.) } +% +% Seemed to need two toks registers. +% \begin{macrocode} +\newtoks\@temptokenb +% \end{macrocode} +% +% \begin{macrocode} +\newtoks\xparsed@args +% \end{macrocode} +% +% +% \begin{macro}{\DeclareDocumentCommand} +% Args: |#1| csname, +% |#2| soom argument spec, +% |#3| code +% +% In |#2| currently supported types are: +% s star, +% o \oarg{optional}, +% m \marg{mandatory}.\footnote{More added in reimplementation below.} +% +% |#3| is just grabbed so as to not get a space in the argument spec +% for definition. +% +% \begin{macrocode} +\long\def\DeclareDocumentCommand #1 #2 #3{ +% \end{macrocode} +% +% Needed to count no of arguments +% \begin{macrocode} + \@tempcnta\z@ +% \end{macrocode} +% +% Builds up list of argument parsers |\@ddc@s\@ddc@m| etc +% \begin{macrocode} + \toks@{} +% \end{macrocode} +% +% Builds up |#1#2#3#4| argument spec +% \begin{macrocode} + \@temptokena\toks@ +% \end{macrocode} +% +% Builds up list of m-argument parsers |\@ddc@m\@ddc@m| +% occurred since start or since argument of another type. +% \begin{macrocode} + \@temptokenb\toks@ +% \end{macrocode} +% +% Start parsing argument spec +% \begin{macrocode} + \@ddc#2X +% \end{macrocode} +% +% Define top level command, this just has the wrapper command +% |\@ddc@| then the argument grabbers from |\toks@| then the original +% command name (in case we need to |\protect|) then the internal +% command with the code. +% The |\long| below could be |\relax| if wanted to have a star-non-long +% form of this, cf |\newcommand*|. The argument preamble for +% |\def| comes from |\@temptokena|. +% \begin{macrocode} + \edef#1{ + \noexpand\@ddc@ + {\the\toks@} + \expandafter\noexpand\csname\string#1\endcsname + \noexpand#1 + } + \long\expandafter\def\csname\string#1\expandafter\endcsname + \the\@temptokena{#3}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareDocumentEnvironment} +% The implementation here could save a csname or two per environment +% if |\begin| and especially |\end| were modified but that not done here +% so each end code responsible for getting its own arguments. +% +% Arguments: |#1| env name, +% |#2| soom spec, +% |#3| begin code, +% |#4| end code. +% +% \begin{macrocode} +\long\def\DeclareDocumentEnvironment#1#2#3#4{ + \expandafter\DeclareDocumentCommand\csname #1\endcsname{#2}{ + \xparsed@args\toks@ + #3} + \expandafter\let\csname end #1\endcsname\@parsed@endenv + \long\expandafter\def\csname end \string\\#1\expandafter\endcsname + \the\@temptokena {#4}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@parsed@endenv} +% All end codes are let to this. (Could be merged into |\end|.) +% \begin{macrocode} +\def\@parsed@endenv{ + \expandafter\@parsed@endenv@\the\xparsed@args} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@parsed@endenv@} +% Helper that just replaces the internal name of the begin code +% with that of the end code. +% \begin{macrocode} +\def\@parsed@endenv@#1{ + \csname end\string#1\endcsname} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@ddc@} +% +% Arguments: |#1| set of argument grabbers, +% |#2| internal command, +% |#3| top level command for |\protect|ing. +% +% \begin{macrocode} +\def\@ddc@#1#2#3{ + \ifx\protect\@typeset@protect + \expandafter\@firstofone + \else + \protect#3\expandafter\@gobble + \fi +% \end{macrocode} +% +% The command+arguments so far are kept in a token register until +% the last moment for ease of processing. So need to initialise +% that and use it at the end. +% \begin{macrocode} + {\toks@{#2} #1\the\toks@}} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@ddc} +% Argument: |#1| one of s o m (or X denoting end of parsing). +% \begin{macrocode} +\def\@ddc#1{ + \ifx #1X +% \end{macrocode} +% fini +% \begin{macrocode} + \else + \ifx #1m +% \end{macrocode} +% If doing an m, just stick another |\@ddc@m| in a temporary list. +% \begin{macrocode} +% \@temptokenb\expandafter{% +% \the\@temptokenb +% \@ddc@m} + \addto@hook\@temptokenb m + \else +% \end{macrocode} +% +% Otherwise for o and s +% in |\toks@| first add any `m' argument parsers saved up +% then add |\@ddc@o| or |\@ddc@s|. +% \begin{macrocode} + \toks@\expandafter{% + \the\expandafter\toks@ + \csname @ddc@\the\@temptokenb\expandafter\endcsname + \csname @ddc@#1\endcsname} +% \end{macrocode} +% +% Clear list of m's: +% \begin{macrocode} + \@temptokenb{} + \fi +% \end{macrocode} +% +% Add one to argument count. +% \begin{macrocode} + \advance\@tempcnta\@ne +% \end{macrocode} +% +% Internally all arguments are non delimited args, so add +% |#|\meta{n} to the list in |\@temptokena| +% \begin{macrocode} + \@temptokena\expandafter{ + \the\expandafter\@temptokena\expandafter##\the\@tempcnta} +% \end{macrocode} +% +% Loop: +% \begin{macrocode} + \expandafter + \@ddc +% \end{macrocode} +% +% \begin{macrocode} + \fi} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@ddc@s} +% Argument: |#1| any remaining argument grabbers (+ |\the|) +% \begin{macrocode} +\long\def\@ddc@s#1\toks@{ +% \end{macrocode} +% +% put back the rest of the argument grabbers, but add new +% (boolean) argument to list of arguments inside the register. +% \begin{macrocode} + \@ifstar + {\addto@hook\toks@\BooleanTrue #1\toks@} + {\addto@hook\toks@\BooleanFalse #1\toks@}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@m} +% Arguments: |#1| any remaining argument grabbers (+ |\the|), +% |#2| argument to be grabbed. +% \begin{macrocode} +\long\def\@ddc@m#1\toks@#2{ +% \end{macrocode} +% put back the rest of the argument grabbers, but copy +% argument to list of arguments inside the toks register. +% Any `m' at the end will be discarded and the internal +% command will pick up its own arguments. +% \begin{macrocode} + \addto@hook\toks@{{#2}} #1\toks@} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@o} +% Argument: |#1| any remaining argument grabbers (+ |\the|). +% \begin{macrocode} +\long\def\@ddc@o#1\toks@{ +% \end{macrocode} +% +% Put back the rest of the argument grabbers, but copy +% argument (now with |{}| or |\NoValue| to list of arguments +% inside toks register. +% \begin{macrocode} + \@ifnextchar[ + {\@ddc@o@{#1}} + {\addto@hook\toks@\NoValue #1\toks@}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@o@} +% Helper to remove []. +% \begin{macrocode} +\long\def\@ddc@o@#1[#2]{ + \addto@hook\toks@{{#2}} #1\toks@} +% \end{macrocode} +% \end{macro} +% +% +% +% \subsection{A Mittelbach update to the Carlisle implementation +% supporting O with default for optional arg and c for coordinates +% --- prove of concept only} +% +% Only changed and new commands are listed. +% +% +% \begin{macro}{\@ddc} +% The big switch that builds up the parser for the document command. +% +% The complexity of the |\@ddc| rewrite suggests that there might +% be better ways to do it, but for a proto-type solution this is +% fine enough. +% +% \begin{macrocode} +\def\@ddc#1{ + \ifx #1X +% \end{macrocode} +% Normally we do nothing at this point and don't pick up the +% trailing mandatory args into |\toks@| but if we want to reuse the +% argument list in an end environment we have to so |\perhaps@grab@ms| +% is normally |\relax| but might be |\grab@ms| instead. +% \begin{macrocode} + \perhaps@grab@ms + \else + \ifx #1m +% \end{macrocode} +% Just record how many m's seen so far +% \begin{macrocode} + \addto@hook\@temptokenb m + \else +% \end{macrocode} +% If anything other than an m is scanned we add to |\toks@| and +% argument grabber that gets all m's in one go rather than argument +% grabbers that pick up each m at a time. Right now this +% unnecessarily adds |\@ddc@x| if no m's have been +% seen.\footnote{fix, see also below} +% \begin{macrocode} + \toks@\expandafter{% + \the\expandafter\toks@ + \csname @ddc@x\the\@temptokenb\expandafter\endcsname + \csname @ddc@#1\endcsname} + \@temptokenb{} +% \end{macrocode} +% In case of |O| and |C| we have to grab the default next. +% \begin{macrocode} + \ifx #1O + \let\next@ddc\grab@default + \else + \ifx #1C + \let\next@ddc\grab@default + \fi + \fi + \fi + \advance\@tempcnta\@ne + \@temptokena\expandafter{ + \the\expandafter\@temptokena\expandafter##\the\@tempcnta} + \expandafter + \next@ddc + \fi +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\next@ddc} +% By default the loop in the |\@ddc| code above calls itself +% recursively until the whole spec is processed. +% \begin{macrocode} +\let\next@ddc\@ddc +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\grab@default} +% However if we've seen an |O| we need to grab the default value first. +% \begin{macrocode} +\def\grab@default #1{ + \toks@\expandafter{% + \the\toks@ + {#1}} + \let\next@ddc\@ddc + \@ddc +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\@ddc@O} +% This command expects the default value (to use if no |[| is +% parsed) after it. +% \begin{macrocode} +\long\def\@ddc@O#1#2\toks@{ + \@ifnextchar[ + {\@ddc@o@{#2}} + {\addto@hook\toks@{{#1}} #2\toks@}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@} +% We look for the `(' and signal an error +% if not found. By using |\@ifnextchar| this also takes care of any +% space tokens in front ot the the parentheses. +% \begin{macrocode} +\long\def\@ddc@c#1\toks@{ + \@ifnextchar ( + {\@ddc@c@ #1} + {\PackageError{xparse}{Missing~ coordinate~ argument} + {A~ value~ of~ (0,0)~ is~ assumed} + \addto@hook\toks@{{00}} #1\toks@} + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@c@} +% Helper for |\@ddc@c| and |\@ddc@C| below to parse a |(x,y)| if we +% know it is there. +% \begin{macrocode} +\long\def\@ddc@c@#1(#2,#3){ + \addto@hook\toks@{{{#2}{#3}}} #1\toks@} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@C} +% This way we can also directly implement the optional argument case in +% a natural way. +% \begin{macrocode} +\long\def\@ddc@C#1#2\toks@{ + \@ifnextchar ( + {\@ddc@c@ #2} + {\addto@hook\toks@{{#1}} #2\toks@}} +% \end{macrocode} +% \end{macro} +% +% +% +% Normally we don't pick up trailing m-args but if we do we grab them +% all at once. +% \begin{macrocode} +\let\perhaps@grab@ms\relax +\def\grab@ms { + \toks@\expandafter{ + \the\expandafter\toks@ + \csname @ddc@x\the\@temptokenb\endcsname +}} +% \end{macrocode} +% +% \begin{macro}{\@ddc@xm} +% Instead of |\@ddc@m| we use |\@ddc@xm| as with the implementation +% below we might have a need for |\@ddc@x| (that is no m's pending) +% and this would result in a name clash. A potentially better +% implementation (cause faster) would be not to use |\@temptokenb| +% above to record the number of m's seen but a counter register and +% generate grabber function names containing the number in their +% name. This way one could better single out the empty case which +% currently will always result and a |\@ddc@x| grabber doing +% nothing. +% \begin{macrocode} +\let\@ddc@m\undefined +\long\def\@ddc@xm#1\toks@#2{ + \addto@hook\toks@{{#2}} #1\toks@} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@ddc@xmm} +% \begin{macro}{\@ddc@xmmm} +% \begin{macro}{\@ddc@xmmm...} +% Arguments: |#1| any remaining argument grabbers (+ |\the|), +% |#2#3| argument to be grabbed; and so on. There can be at most 8 +% such mandatory arguments in the variations defined below. +% \begin{macrocode} +\long\def\@ddc@xmm#1\toks@#2#3{ +% \end{macrocode} +% Put back the rest of the argument grabbers, but copy +% argument to list of arguments inside the toks register. +% Any `m' at the end will be discarded and the internal +% command will pick up its own arguments. +% \begin{macrocode} + \addto@hook\toks@{{#2}{#3}} #1\toks@} +% \end{macrocode} +% +% And here are the cases for 3 to eight upcoming mandatory args: +% \begin{macrocode} +\long\def\@ddc@xmmm#1\toks@#2#3#4{ + \addto@hook\toks@{{#2}{#3}{#4}} #1\toks@} +\long\def\@ddc@xmmmm#1\toks@#2#3#4#5{ + \addto@hook\toks@{{#2}{#3}{#4}{#5}} #1\toks@} +\long\def\@ddc@xmmmmm#1\toks@#2#3#4#5#6{ + \addto@hook\toks@{{#2}{#3}{#4}{#5}{#6}} #1\toks@} +\long\def\@ddc@xmmmmmm#1\toks@#2#3#4#5#6#7{ + \addto@hook\toks@{{#2}{#3}{#4}{#5}{#6}{#7}} #1\toks@} +\long\def\@ddc@xmmmmmmm#1\toks@#2#3#4#5#6#7#8{ + \addto@hook\toks@{{#2}{#3}{#4}{#5}{#6}{#7}{#8}} #1\toks@} +\long\def\@ddc@xmmmmmmmm#1\toks@#2#3#4#5#6#7#8#9{ + \addto@hook\toks@{{#2}{#3}{#4}{#5}{#6}{#7}{#8}{#9}} #1\toks@} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macro}{\@ddc@xmmmmmmmmm} +% If we grab arguments even if they are all mandatory we might have +% even 9 such arguments, thus we also need: +% \begin{macrocode} +\long\def\@ddc@xmmmmmmmmm\the\toks@#1#2#3#4#5#6#7#8#9{ + \addto@hook\toks@{{#1}{#2}{#3}{#4}{#5}{#6}{#7}{#8}{#9}}\the\toks@} +% \end{macrocode} +% And in that case we also need to provide |\@ddc@x| as that name will +% be executed if there are no trailing mandatory arguments. +% \begin{macrocode} +\let\@ddc@x\relax +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\DeclareDocumentEnvironment} +% Fixing |\DeclareDocumentEnvironment| to not choke on the spec +% |m|. Interestingly enough |mm| does work with the old +% implementation: it simply grabs |\@checkend{name}| whereas the +% first only grabs |\@checkend| leaving |{name}| around for +% typesetting :-) +% +% If we don't make the arguments available in the end code we +% should most likely revert to David's original code which worked +% without assigning everything to toks registers (or at least check +% what is faster!) +% \begin{macrocode} +\long\def\DeclareDocumentEnvironment#1#2#3#4{ + \expandafter\DeclareDocumentCommand\csname #1\endcsname{#2}{ +% \end{macrocode} +% After |\DeclareDocumentCommand| has parsed the arguments the +% parsing result is available in |\@toks| except that trailing +% |m|'s are picked up directly and their values are therefore not +% part of this token register. So either we have to slow down +% everything by individually parsing those as well or this bright +% idea is not working. For the moment i disabled it again! +% \begin{macrocode} +% \xparsed@args\toks@ + #3} +% \end{macrocode} +% In that case the following can be simplified as well: +% \begin{macrocode} + \@namedef{end #1}{#4} +% \expandafter\let\csname end #1\endcsname\@parsed@endenv +% \long\expandafter\def\csname end \string\\#1\expandafter\endcsname +% \the\@temptokena{#4} +} +% \end{macrocode} +% And those are no longer necessary: +% \begin{macrocode} +\let\@parsed@endenv\undefined +\let\@parsed@endenv@\undefined +% \end{macrocode} +% +% The above does the fixing by not providing the arguments to the +% end command. The alternative is to do full parsing and could +% perhaps look more or less like this: +% \begin{macrocode} +%<*perhaps> +\long\def\DeclareDocumentEnvironment#1#2#3#4{ + \let\perhaps@grab@ms\grab@ms + \expandafter\DeclareDocumentCommand\csname #1\endcsname{#2}{ +% \end{macrocode} +% I think we need as a safety measure add a group here or else the +% code will fail over if people use it without |\begin|\ldots +% |\end|. +% Or not? I don't really like it but then i don't want to maintain +% a private stack here. +% \begin{macrocode} + \begingroup + \xparsed@args\toks@ + #3} + \let\perhaps@grab@ms\relax + \expandafter\let\csname end #1\endcsname\@parsed@endenv + \long\expandafter\def\csname end \string\\#1\expandafter\endcsname + \the\@temptokena {#4} +} +% \end{macrocode} +% Same as in David's again except that we have the added group now. +% \begin{macrocode} +\def\@parsed@endenv{ + \expandafter\@parsed@endenv@\the\xparsed@args\endgroup} +\def\@parsed@endenv@#1{ + \csname end\string#1\endcsname} +%</perhaps> +% \end{macrocode} +% However the above will fail with |\begin{macro}| code of the +% \texttt{doc} package as this code cancels the outer group so it is +% dangerous and for the moment i have not activated it. +% +% \end{macro} +% +% \subsection{A Quark-like datatype} +% +% If it turns out that the only quark thingie is going to be +% |\NoValue| then this can be streamlined for speed (and it looks +% like this is the case)! +% +% \begin{macro}{\IfSomethingTF} +% \begin{macro}{\IfSomethingT} +% \begin{macro}{\IfSomethingF} +% Setting up the stage \ldots +% \begin{macrocode} +\def\IfSomethingTF#1{\def\something@in{#1} \If@SomethingTF} +\def\IfSomethingT#1#2#3{\def\something@in{#1} + \If@SomethingTF{#2}{#3}\@empty} +\def\IfSomethingF#1#2#3{\def\something@in{#1} + \If@SomethingTF{#2}\@empty{#3}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\If@SomethingTF} +% \ldots and then for the recursive part: +% \begin{macrocode} +\def\If@SomethingTF#1{ + \def\something@tmp{#1} + \ifx\something@tmp\something@in +%fini true + \expandafter\@secondofthree + \else + \expandafter\def\expandafter\something@tmpb\expandafter{#1} + \ifx\something@tmp\something@tmpb +%fini false + \expandafter\expandafter\expandafter\@thirdofthree + \else +%try again expanded + \expandafter\expandafter\expandafter\@firstofone + \fi + \fi + {\expandafter\If@SomethingTF\expandafter{#1}} +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@secondofthree} +% \begin{macro}{\@thirdofthree} +% Some helpers missing in \LaTeX{}; the others are |\long| so we make +% those long as well: +% \begin{macrocode} +\long\def\@secondofthree#1#2#3{#2} +\long\def\@thirdofthree #1#2#3{#3} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \subsection{Testing for \texttt{\textbackslash NoValue}} +% +% +% \begin{macro}{\NoValue} +% \begin{macrocode} +\def\NoValue{-NoValue-} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\NoValueInIt} +% might be handy sometimes\ldots +% \begin{macrocode} +\def\NoValueInIt{\NoValue} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\IfNoValueTF} +% \begin{macro}{\IfNoValueT} +% \begin{macro}{\IfNoValueF} +% \begin{macrocode} +\def\IfNoValueTF{\IfSomethingTF\NoValue} +\def\IfNoValueT {\IfSomethingT \NoValue} +\def\IfNoValueF {\IfSomethingF \NoValue} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\IfValueTF} +% \begin{macro}{\IfValueT} +% \begin{macro}{\IfValueF} +% \begin{macrocode} +\def\IfValueTF #1 #2 #3 { \IfNoValueTF {#1} {#3} {#2} } +\let \IfValueT \IfNoValueF +\let \IfValueF \IfNoValueT +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \subsection{A Boolean datatype} +% +% \begin{macro}{\BooleanFalse} +% \begin{macro}{\BooleanTrue} +% \begin{macrocode} +\def\BooleanFalse{TF} +\def\BooleanTrue{TT} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\IfBooleanTF} +% \begin{macro}{\IfBooleanT} +% \begin{macro}{\IfBooleanF} +% \begin{macrocode} +\def\IfBooleanTF #1 { + \if#1 + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo + \fi +} +\def\IfBooleanT #1 #2 { + \IfBooleanTF {#1} {#2} \@empty +} +\def\IfBooleanF #1 { + \IfBooleanTF {#1} \@empty +} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% +% \Finale +% +\endinput diff --git a/Master/texmf-dist/source/latex3/xparse/xparse.ins b/Master/texmf-dist/source/latex3/xparse/xparse.ins new file mode 100644 index 00000000000..0a785f6f587 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xparse/xparse.ins @@ -0,0 +1,13 @@ +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble +\endpreamble + +\generate{% + \file{ldcsetup.sty}{\from{ldcsetup.dtx}{package}} + \file{xparse.sty}{\from{xparse.dtx}{package}} + } + +\endbatchfile diff --git a/Master/texmf-dist/source/latex3/xtheorem/xtheorem.dtx b/Master/texmf-dist/source/latex3/xtheorem/xtheorem.dtx new file mode 100644 index 00000000000..c07f240a4e9 --- /dev/null +++ b/Master/texmf-dist/source/latex3/xtheorem/xtheorem.dtx @@ -0,0 +1,386 @@ +% \iffalse +%% +%% (C) Copyright 1999 Achim Blumensath +%% All rights reserved. +%% +%% Not for general distribution. In its present form it is not allowed +%% to put this package onto CD or an archive without consulting the +%% the authors. +%% +%<*dtx> + \ProvidesFile{xtheorem.dtx} +%</dtx> +%<package>\NeedsTeXFormat{LaTeX2e} +%<package>\ProvidesPackage{xtheorem} +%<driver>\ProvidesFile{xtheorem.drv} +% \fi +% \ProvidesFile{xtheorem.dtx} + [1999/12/19 v0.1 theorem styles] +% +% \iffalse +%<*driver> + \documentclass{ltxdoc} + \usepackage{textcomp} + +% \usepackage{xparse,xlists,xlists-samples} +% \usepackage{ldcdoc} + +% next three definitions are big hacks to run the file +% without the above packages +% +\newcommand\NoValue{\texttt{\textbackslash NoValue}} + +\newenvironment{TemplateInterfaceDescription}[1] + {\subsection{The Template Type `#1'}% + \begingroup\description + \def\TemplateArgument##1##2{\item[Arg: ##1]##2\par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics:}}% + } + {\par\bigskip} + +\newenvironment{TemplateDescription}[2] + {\subsection{The Template `#2' (type #1)}% + \subsubsection*{Attributes:}% + \begingroup\description + \def\TemplateKey##1##2##3##4{\item[##1 (##2)]##3% + \ifx\TemplateKey##4\TemplateKey\else +% \hskip0ptplus3em\penalty-500\hskip 0pt plus 1filll Default:~##4% + \hfill\penalty500\hbox{}\hfill Default:~##4% + \nobreak\hskip-\parfillskip\hskip0pt\relax + \fi + \par}% + \def\TemplateSemantics{\enddescription\endgroup + \subsubsection*{Semantics \& Comments:}}% + } + {\par\bigskip} + + \begin{document} + \DocInput{xtheorem.dtx} + \end{document} +%</driver> +% \fi +% +% +% \GetFileInfo{xtheorem.dtx} +% +% \title{The \textsf{xtheorem} package\thanks{This file +% has version number \fileversion, last +% revised \filedate.}} +% \author{AB} +% \date{\filedate} +% +% \maketitle +% +% \tableofcontents +% +% \begin{abstract} +% This is a conversion of the AMS theorem classes to the template +% system. Only the interface was changed, the internals still use +% \LaTeXe\ commands. +% \end{abstract} +% +% \section{Interfaces} +% +% \begin{TemplateInterfaceDescription}{theoremstyle} +% +% \TemplateArgument{1} +% {Text of the number of the theorem (e.g., \verb|A.1|), or +% \NoValue\ to indicate that the theorem is unnumbered.} +% +% \TemplateArgument{2} +% {Name of the theorem (e.g. \verb|Theorem|, \verb|Lemma|).} +% +% \TemplateArgument{3} +% {Additional note (e.g. \verb|see [12]|), or \NoValue.} +% +% \TemplateSemantics +% +% This template starts a new environment, typesets the head of a +% theorem, and sets fonts for the body of the theorem. The +% environment is ended by an \verb|\@endtheorem| command. +% +% If the first argument is given, it is printed as the number part. +% The second argument contains the name of the theorem, and the +% third one may contain an additional note. +% +% For instance, the arguments \verb|2.1|, \verb|Lemma|, and +% \verb|Rabin~1960| could produce the output +% +% \medskip +% \noindent\textbf{Lemma 2.1 }(Rabin 1960)\textbf. +% +% \medskip\noindent +% where the following text is set in italic. +% +% \end{TemplateInterfaceDescription} +% +% +% \begin{TemplateDescription}{theoremstyle}{std} +% +% \TemplateKey{pre-skip}{l} +% {Skip above the theorem.} +% {|topsep|} +% \TemplateKey{post-skip}{l} +% {Skip below the theorem.} +% {|topsep|} +% \TemplateKey{body-style}{f0} +% {Commands to be executed before the body of the theorem in +% order to set fonts, etc.} +% {italic} +% \TemplateKey{head-style}{f0} +% {Commands to set the font of the head.} +% {bold} +% \TemplateKey{note-style}{f0} +% {Commands to set the font of the note.} +% {medium upright font} +% \TemplateKey{head-punct}{f0} +% {Text after the head.} +% {|.|} +% \TemplateKey{head-format}{f3} +% {Format of the head.} +% {Name Number (Note)} +% \TemplateKey{head-indent}{l} +% {Indent of the head.} +% {none} +% \TemplateKey{head-sep}{l} +% {Space after the head.} +% {5pt $\pm$ 1pt} +% \TemplateKey{post-head-action}{f0} +% {Command to be executed after the head (e.g., a line break).} +% {none} +% +% \TemplateSemantics +% This are all parameters provided by the AMS package, except `swaphead' +% which can be simulated by \verb|head-format|. +% +% \end{TemplateDescription} +% +% \paragraph{Problem.} +% The current solution for `head-format' is very clumsy. Perhaps it would +% be better to pass just the name of a template which does the layout +% instead of the actual code. +% +% \medskip +% \DescribeMacro\newtheorem +% The \verb|\newtheorem| command defines a new type of theorem. It takes +% the following arguments: +% +% \medskip +% \verb|\newtheorem|[|*|]$\langle$style$\rangle$\relax +% $\langle$name$\rangle$[share counter]$\langle$label$\rangle$\relax +% [count relative] +% +% \medskip\noindent +% and defines an environment named `name'. The arguments have the +% following meanings: +% \begin{description} +% \item[|*|] If present the theorem is unnumbered, otherwise it is +% numbered. +% \item[style] The name of an instace of the `theoremstyle' template +% which is used to typeset the theorem. +% \item[name] The name of the new environment. +% \item[share counter] (optional) The label of another defined theorem. +% If present both kinds of theorem share a common counter. +% \item[label] The name of the theorem which should appear in its head. +% \item[count relative] If present the counter is reset to 1 everything +% the counter with this name is changed (e.g., |section| or |chapter|). +% \end{description} +% +% For instance, the following definitions create environments named +% |Thm|, |Prop|, |Lem|, |Cor|, |Def|, |Rem|, and |Exam|. The first +% five share a common counter which is relative to the current +% section, the last two are unnumbered. +% \begin{verbatim} +% \newtheorem{plain}{Thm}{Theorem}[section] +% \newtheorem{plain}{Prop}[Thm]{Proposition} +% \newtheorem{plain}{Lem}[Thm]{Lemma} +% \newtheorem{plain}{Cor}[Thm]{Corollary} +% \newtheorem{definition}{Def}[Thm]{Definition} +% \newtheorem*{remark}{Rem}{Remark} +% \newtheorem*{remark}{Exam}{Example} +% \end{verbatim} +% +% \section{Implementation} +% +% \begin{macrocode} +%<*package> +\RequirePackage{xparse} +\RequirePackage{template} + +\IgnoreWhiteSpace +% \end{macrocode} +% +% \begin{macrocode} +\DeclareTemplateType{theoremstyle}{3} + +\newskip\TSpre@skip +\newskip\TSpost@skip +\newdimen\TShead@indent +\newskip\TShead@sep + +\DeclareTemplate{theoremstyle}{std}{3} +{ + pre-skip =l [\DelayEvaluation{\topsep}] \TSpre@skip, + post-skip =l [\DelayEvaluation{\topsep}] \TSpost@skip, + body-style =f0 [\itshape] \TSbody@style, + head-style =f0 [\bfseries] \TShead@style, + note-style =f0 [\fontseries\mddefault\upshape] \TSnote@style, + head-punct =f0 [.] \TShead@punct, + head-format =f3 [\IfNoValueF{#1}{#1\IfNoValueF{#2}{\space}} + \IfNoValueF{#2}{\textup{#2}} + \IfNoValueF{#3}{\space{\TSnote@style(#3)}}] + \TShead@format, + head-indent =l [0pt] \TShead@indent, + head-sep =l [5pt plus 1pt minus 1pt] \TShead@sep, + post-head-action =f0 [] \TSpost@head@action +} +{ + \DoParameterAssignments + \ifhmode\unskip\unskip\par\fi + \normalfont + \trivlist + \let\thmheadnl\relax + \@topsep\TSpre@skip + \@topsepadd\TSpost@skip + \IfNoValueF{#1} + {\refstepcounter{#1}} + \deferred@thm@head{ + \TShead@style + \hskip\TShead@indent + \IfNoValueTF{#1} + {\TShead@format{#2}{#1}{#3}} + {\TShead@format{#2}{\csname the#1\endcsname}{#3}} + \TShead@punct + \TSpost@head@action + \hskip\TShead@sep + } + \TSbody@style + \ignorespaces +} +% \end{macrocode} +% These functions are used by the template above. They are copied +% straight away from amsclass.dtx. +% \begin{macrocode} +\let\adjust@parskip@nobreak=\@nbitem +% \end{macrocode} +% +% \begin{macrocode} +\newtoks\dth@everypar +\dth@everypar={ + \@minipagefalse + \global\@newlistfalse + \if@inlabel + \global\@inlabelfalse + \begingroup + \setbox\z@\lastbox + \ifvoid\z@ \kern-\itemindent \fi + \endgroup + \unhbox\@labels + \fi + \if@nobreak + \@nobreakfalse + \clubpenalty\@M + \else + \clubpenalty\@clubpenalty + \everypar{} + \fi +} +% \end{macrocode} +% +% \begin{macrocode} +\def\deferred@thm@head#1{% + \if@inlabel \indent \par \fi % eject a section head if one is pending + \if@nobreak + \adjust@parskip@nobreak + \else + \addpenalty\@beginparpenalty + \addvspace\@topsep + \addvspace{-\parskip}% + \fi + \global\@inlabeltrue + \everypar\dth@everypar + \sbox\@labels{\normalfont#1}% + \ignorespaces +} +% \end{macrocode} +% The usual styles `plain', `definition', and `remark'. +% \begin{macrocode} +\DeclareInstance{theoremstyle}{plain}{std}{} + +\DeclareInstance{theoremstyle}{definition}{std} +{ + body-style = \normalfont +} + +\DeclareInstance{theoremstyle}{remark}{std} +{ + pre-skip = \DelayEvaluation{0.5\topsep}, + post-skip = \DelayEvaluation{0.5\topsep}, + body-style = \normalfont, + head-style = \itshape +} +% \end{macrocode} +% The command to end a theorem. +% \begin{macrocode} +\def\@endtheorem{\endtrivlist\@endpefalse } +% \end{macrocode} +% +% |newtheorem| just checks all cases and defines the appropriate +% environment. +% \begin{macrocode} +\DeclareDocumentCommand{\newtheorem}{smmomo} +{ + \expandafter\@ifdefinable\csname #3\endcsname + { + \global\expandafter\let\csname end#3\endcsname\@endtheorem + \IfBooleanTF{#1} + { + \expandafter\DeclareDocumentCommand\csname #3\endcsname{o} + {\UseInstance{theoremstyle}{#2}{\NoValue}{#5}{##1}} + } + { + \IfNoValueTF{#4} + { + \IfNoValueTF{#6} + { + \newcounter{#3} + } + { + \newcounter{#3}[#6] + \expandafter\xdef\csname the#3\endcsname{ + \expandafter\noexpand\csname the#6\endcsname + \@thmcountersep\@thmcounter{#3}} + } + \expandafter\DeclareDocumentCommand\csname #3\endcsname{o} + {\UseInstance{theoremstyle}{#2}{#3}{#5}{##1}} + } + { + \@ifundefined{c@#4} + { + \@nocounterr{#4} + } + { + \expandafter\xdef\csname the#3\endcsname{ + \expandafter\noexpand\csname the#4\endcsname} + \expandafter\DeclareDocumentCommand\csname #3\endcsname{o} + {\UseInstance{theoremstyle}{#2}{#4}{#5}{##1}} + } + } + } + } +} +% \end{macrocode} +% +% \begin{macrocode} +\endinput +% \end{macrocode} +% +% \begin{macrocode} +%</package> +% \end{macrocode} +% +% +% \Finale +% +\endinput diff --git a/Master/texmf-dist/source/latex3/xtheorem/xtheorem.ins b/Master/texmf-dist/source/latex3/xtheorem/xtheorem.ins new file mode 100644 index 00000000000..f9ed9513d7d --- /dev/null +++ b/Master/texmf-dist/source/latex3/xtheorem/xtheorem.ins @@ -0,0 +1,14 @@ +\input docstrip +\keepsilent +\askforoverwritefalse + +\preamble + +Not for distribution +\endpreamble + +\generate{ + \file{xtheorem.sty}{\from{xtheorem.dtx}{package,trace}} + } + +\endbatchfile |