All Classes and Interfaces
Class
Description
Provides base functionality for the commands and environments that build custom
XML elements.
This builder handles applying accents to characters.
Map defines how unaccented alphabetic characters should map to corresponding
Unicode characters when a particular type of accent is applied (e.g. circumflex).
Defines all of the
AccentMaps for the various types of accents we support.Handles the LaTeX
align environment.Handles the
\\anchor command, generating an XHTML anchor.This token is used as a container for the arguments specified for a particular
Command or Environment.Handles the LaTeX
array environment.Trivial annotation that can be applied to a
getX() method to prevent its
details from being listed by ObjectUtilities.beanToString(Object).Handles
\\mbox, \\fbox and friends.Represents a literal braced section in the original LaTeX document, i.e. something like
{ ... }.Represents a
Command that has been defined internally via a SnugglePackage.Defines a built-in LaTeX environment, as specified within a
SnugglePackage.This handles simple commands that essentially just stand in for single-character identifiers
that don't have any particular meaning when used in MATH mode (e.g. '$').
Trivial implementation of
URIResolver that looks for resources via the
ClassLoader.This interface is used to specify which
FlowTokens are valid as combiner targets
for Commands of type CommandType.COMBINERBase interface for LaTeX commands, i.e. things entered in the form
\\command.Defines how a
BuiltinCommand should append children to the outgoing
DOM tree.Trivial command line interface for running SnuggleTeX on a number of inputs files (or STDIN),
supporting most of the XML- and web-based output options.
Base interface for LaTeX commands and environments.
This token represents a LaTeX
BuiltinCommand.Enumerates different types of LaTeX commands.
This represents the computed or runtime style of a
Token.TeX "Font Family"
TeX Font Size
Simple utility methods for enforcing various types of data constraints.
Enumerates the various types of client-induced errors that can arise when using the
functionality provided by the core SnuggleTeX module.
Defines the groupings for the various types of client-induced errors that can arise
when using the functionality provided by the core SnuggleTeX module.
This defines the default
SnugglePackage (containing BuiltinCommand and
BuiltinEnvironment) supported by SnuggleTeX.Some handy utility methods for managing SnuggleTeX CSS.
Implementation of
NumberMatcher that uses a standard Java DecimalFormat to
match numbers.Default implementation of
TransformerFactoryChooser that uses the usual JAXP factory
lookup mechanisms for XSLT 1.0 stylesheets, and hard-codes to SAXON for XSLT 2.0 stylesheets.Internal callback interface that specifies how to build the real content of a MathML
element.
Trivial enumeration to keep track of where we are in the outgoing DOM.
This is the main entry point into the DOM generation process.
This class is used to specify how you want DOM trees to be built when calling relevant methods
in
SnuggleSession (e.g.Enumerates the various options for representing
InputErrors in the resulting
DOM.This interface allows you to hook into the SnuggleTeX process immediately after the raw
DOM tree has been built.
Trivial "do nothing" handler for commands and environments that don't add anything to
the resulting DOM.
Trivial implementation of
StylesheetCache that actually doesn't cache anything
at all.Trivial implementation of
DOMPostProcessor that hooks into the
MathMLDownConverter.Enumerates the different options that can be used when specifying how to dump
out properties or types in
ObjectDumper.This handles the
\\ensuremath command.Base interface for LaTeX environment, i.e. constructs defined like
\\begin{environment} ...Defines how a
BuiltinEnvironment should append children to the outgoing DOM.Represents a
BuiltinEnvironment.Handles the
eqnarray* environment.Interface representing a code for an Error caused by client input.
Interface representing a grouping for a set of related
ErrorCodes.Special token encapsulating a client error in parsing.
Base class for
Tokens which represent the main "flow" of content, rather than things
like command arguments.Represents a finished "segment" of text in the
WorkingDocument.Handles the
\\getvar macro.Lists various useful (but internal) constants and helper methods.
Handles the SnuggleTeX-specific
\\href command for easily creating web links.Handles the
\\hspace and \\hspace* commands.Read-only view of the current document being parsed, which will change shape as user-defined
macros and environments are being expanded.
Encapsulates an error in the LaTeX input, providing information about what the error is and
where it occurred.
Handles the non-standard
\\ux command to insert a Unicode character into the output.This builder calls back directly to the
DOMBuilder to handle mathematical
tokens with certain types of simple semantic interpretations.This base interface allows some kind of "semantic interpretation" to be associated with a
particular
Token.Defines the different types of interpretations handled by the
Interpretation class
hierarchy.A collection of vaguely useful utilities for doing common I/O and File-related tasks.
Simple utility class that does very basic indenting of LaTeX.
Enumerates the various modes of LaTeX input.
This class reads in SnuggleTeX input and builds a tree of literal parsed
Tokens.Trivial "struct" encapsulating information about the state of a tokenisation mode.
This implementation of
LaTeXTokeniser.Terminator represents terminators specified as regular
expressions.This implementation of
LaTeXTokeniser.Terminator is used to handle fixed Strings as
terminators.Represents the "terminator" characters that signify the end of a parsing mode.
Enumeration of the various "tokenisation modes" we will be running in.
Handles instances of
\\\\, which forces a line break at the given point.This interface allows clients to have control over handling any hypertext links encountered
in commands like
HrefHandler, making it possible to remap links as required.This handles LaTeX list environments (i.e.
Handler for the custom
\\literal command, which allows literal input to be
entered, similar to \\verb with output without changing style.This is used during the build process to create the SnuggleTeX
all-math-characters.txt
from the unicode-math-table.tex from the unicode-math LaTeX package.Supplementary marker interpretation to be attached to operators which can "own big limits",
in the sense that they should be rendered in MathML using munder/mover/munderover
rather than msub/msup/msubsup.
Supplementary interpretation indicating that a certain operator is a MathML bracket.
Represents a mathematical character.
Represents a mathematical character
Represents a character in math mode.
Handles complex Math commands (i.e. ones taking arguments) that map very easily onto
MathML elements where each argument becomes a child element of the resulting MathML
container.
Builds LaTeX math environments.
Handles matched parentheses encapsulated within
CorePackageDefinitions.ENV_BRACKETED
environments.Represents a mathematical function like sin, cos, etc.
Semantic interpretation for a mathematical identifier.
Base for math-specific semantic interpretations.
Handles the mathematical "limit" tokens like
CorePackageDefinitions.CMD_MSUB_OR_MUNDER, generating
either msub or munder as appropriate, with analogous results for
CorePackageDefinitions.CMD_MSUP_OR_MOVER and CorePackageDefinitions.CMD_MSUBSUP_OR_MUNDEROVER.This utility class "down-converts" a DOM
Document so that simple MathML expressions
are replaced by XHTML + CSS alternatives.Trivial
URIResolver that returns an XML Document corresponding to
the current session's CSS Properties when the URI
Globals.CSS_PROPERTIES_DOCUMENT_URN is used.Convenient base for
DOMPostProcessors that might want to do interesting
things to MathML islands, leaving everything else unchanged.Some general utility methods for manipulating MathML via the DOM.
Supplementary interpretation for an operator which may be negated.
Handles the
\\not combiner command.Represents the interpretation of a mathematical number.
Represents a generic Mathematical operator, associating it with the content of
the resulting MathML
mo element.Handles the LaTeX
\\sqrt command, which generates either a msqrt
or mroot depending on whether an optional argument has been passed or not.Handles the
\\stackrel, \\overset and \\underset commands.This map encapsulates how to apply certain types of Mathematical character variants to
"safe and plain" Unicode characters by mapping them to other characters.
This handles changes to the current "mathvariant" caused by things like
\\mathcal
and friends.Defines the (safe) mappings of characters for the different types of "mathvariants"
we support.
Handles the AMSLaTeX
cases and the various matrix environments.Utility class that formats an
InputError in various ways.Example demonstrating a minimal example use of SnuggleTeX.
Trivial "meta"-builder that delegates to a
CommandHandler depending on whether we
are in MATH or TEXT mode.Builds MathML
mrows.Interface for classes which identify numbers in Math mode input.
Trivial but slightly useful helper for creating deep dumps of Objects and their
its properties, which can be useful for displaying status messages and debugging.
This annotation is used by
ObjectDumper to specify how types or properties
should be dumped.Some random "macros" for doing common Object-based tasks.
This builds the content of a (fixed)
CorePackageDefinitions.CMD_PARAGRAPH token.Enumerates the different options that can be used for outputting property values in
ObjectUtilities.beanToString(Object).This token represents the root of a parsed
SnuggleInputImplementation of
TransformerFactoryChooser that is hard-wired to use whichever version
of Saxon can be found in the ClassPath under the net.sf.saxon package hierarchy, thus
providing support for XSLT 2.0.Enumerates the XML serialization methods available.
Implementation of
SerializationSpecifier that can be used for some of the utility
methods in MathMLUtilities.Interface specifying various options for serializing XML produced by SnuggleTeX
and some of its utility classes.
Specifies options for how a
SnuggleSession should parse and process
SnuggleInputs.Provides access to session-related Objects used during the various parts of the snuggle process.
Handles the
\\setvar macro.Very basic but fast implementation of
NumberMatcher that handles western-style
numeric characters, supporting Locale-specific decimal points.Trivial implementation of
StylesheetCache that simply caches all stylesheets
in a HashMap.Represents a "simple" LaTeX token.
This trivial handler takes an Environment or 1-argument Command and simply maps it to
an XHTML element with the given name and CSS class.
Public SnuggleTeX-related constants.
This is the main entry point into SnuggleTeX.
Simple container for an input into SnuggleTeX.
Enumerates the various types of inputs we support.
Helper class that does the job of taking a
SnuggleInput, checking its contents for
allowed Unicode characters, working out how to map absolute offsets into (line,column)
pairs and producing a WorkingDocument for later use.This
RuntimeException is thrown if SnuggleTeX has detected something amiss with its
logic.A
SnugglePackage defines a collection of BuiltinCommands, BuiltinEnvironments,
and ErrorCodes/ErrorGroups that can be registered with a SnuggleEngine
to add in extra functionality.Internal Exception thrown by
SnuggleSession.registerError(InputError) when a parsing
error occurs and the client has requested immediate failure in such circumstances.This
RuntimeException is used to indicate a problem within SnuggleTeX which is due to
a mis-configuration of SnuggleTeX, rather than a problem with client input or bad logic within
SnuggleTeX.This represents a single "job" for SnuggleTeX.
Trivial enumeration which specifies the possible actions to perform once we
finish writing with the various
SnuggleSession.writeWebPage(WebPageOutputOptions, OutputStream)
methods.FIXME: Document this type!
A partial result of parsing one or more
SnuggleInputs by a SnuggleSession,
created via SnuggleSession.createSnapshot().A collection of occasionally useful SnuggleTeX-related utility methods, as well
as some more general LaTeX stuff.
Creates preset spacing elements in MATH and/or TEXT modes.
Some vaguely useful String-related methods that are used from
time to time.
Represents styled text in either MATH and/or TEXT Modes.
This calculates the
ComputedStyle for each raw parsed Token.Handles the internal <style> environment delimiting a branch of content to be
rendered in a different style.
This runs after
TokenFixer and groups style changes together using the
pseudo-environment CorePackageDefinitions.ENV_STYLE, which makes DOM building
much easier.Encapsulates a simple cache for the internal XSLT stylesheets used by SnuggleTeX.
Trivial helper class to manage the loading of SnuggleTeX's internal stylesheets, using
a
StylesheetCache to cache stylesheets for performance.Handles the (rather complex)
tabular environment.Handles things like the
\\underline command, which are simpler than the classic
LaTeX style controls.This enumeration specifies how text-based
FlowTokens should be handled when being merged
into the resulting XHTML DOM.Used for things like
\\ldots, which work in both Math and Text modesBase interface for a parsed SnuggleTeX token.
This takes the parse tree after
StyleEvaluator has run and performs grouping operations
on the FlowTokens to convert them to a more tree-like structure that is easier to handle.Enumerates the various types of LaTeX tokens.
This interface allows you to specify how XSLT implementations should be instantiated.
Handles
\\units, generating an mi element of the form:Trivial wrapper Object that encapsulates the results of
MathMLUtilities.unwrapParallelMathMLDOM(Element).Represents a user-defined
Command, i.e. one defined in the client data using
\\newcommand.Partial base class for
UserDefinedCommands and UserDefinedEnvironments.Represents a user-defined environment, created by clients using the
\\newenvironment command.Manages the values of user-defined variables.
Handles the
verbatim environment and \\verb command.A collection of useful constants for various W3C-related topics (e.g. system identifiers,
namespaces, etc...).
Builds a web page from a
List of fixed FlowTokens, using the supplied
WebPageOutputOptions to determine the exact form of the results.Example demonstrating using SnuggleTeX to create an HTML 5 + MathJax web page,
outputting the resulting web page content to the console.
Builds on
XMLStringOutputOptions to add in options for configuring how to build a
web page using the relevant methods in SnuggleSession
(e.g.Deprecated.
Utility class that creates pre-configured and usable
WebPageOutputOptions instances
for various common scenarios.Deprecated.
As of SnuggleTeX 1.3.0, use
WebPageOutputOptionsBuilder.Represents the "working view" of the current
SnuggleInput document.Represents a block of text that has been imported into this document.
Holds information about how a particular index in the document is resolved against the
WorkingDocument.Slice
in which it is contained.Represents a contiguous portion of the document hat comes from the same
WorkingDocument.CharacterSource.Marker interface that can be applied to classes that provide information for a
WorkingDocument.CharacterSource.Implementation of
WorkingDocument.SourceContext that represents the result of a substitution.Handles lonely instances of
\\xmlAttr, which results in CoreErrorCode.TDEX02
being emitted.Builds custom block XML elements.
Builds custom inline XML elements.
Trivial handler for the
\\xmlName and \\xmlId commands.This example generalises
MinimalExample to create a slightly
more interesting output.Builds on
DOMOutputOptions to add in options for configuring how to build an
serialized output consisting of an XML (or possibly HTML) String using the relevant methods
in SnuggleSession
(e.g.Handles the special
xmlUnparsed command and environment.Some trivial little helpers for creating suitably-configured
TransformerFactory
instances.
WebPageOutputOptionsBuilderto generate different types of web pages.