As noted in Section 3.10 Accent Operators of the UnicodeMath specification, the most common math accents are (along with their TeX names)
These and more accents are described in Section 2.6 Accented Characters and 3.2.7 Combining Marks in Unicode Technical Report #25, Unicode Support For Mathematics. More generally, the Unicode ranges U+0300..U+036F and U+20D0..U+20EF have these and other accents that can be used for math.
The Windows Character Map program shows that the Cambria Math font has all combining marks in the range 0300..036F as well as 20D0..20DF, 20E1, 20E5, 20E6, 20E8..20EA. The range 0300..036F used as math accents in Word looks like
Except for the horizontal overstrikes and the doublecharacter accents shown in red, all these work as math accents in Microsoft Office apps, although many aren’t used in math. In keeping with the Unicode Standard, UnicodeMath represents an accent by its Unicode character, placing the accent immediately after the base character. There’s no need for doublecharacter accents in Microsoft Office math since the corresponding “single” character accents expand to fit their bases as in
In UnicodeMath, this is given by (a+b)~, where ~ can be entered using the TeX control word \tilde. This is simpler than TeX, which uses \widetilde{a+b} for automatically sized tildes rather than \tilde{a+b}.
The combining mark in the range 20D0..20EF that work as accent objects in Office math zones areYou can test accents that don’t have TeX control words by inserting a math zone (type alt+=), type a nonhex letter followed by the Unicode value, alt+x, space. For example, alt+=, z, 36F, alt+x, space gives
MathML 1 was released as a W3C recommendation in April 1998 as the first XML language to be recommended by the W3C. At that time, Unicode was just starting to take hold as Microsoft Word 97 and Excel 97 had switched to Unicode. [La]TeX was developed before Unicode 1.0, so it relied on control words. Accordingly, it was common practice in 1998 to use control words or common spacing accents to represent accents instead of the Unicode combining marks even though many accents didn’t have a unified standardized representation. Unicode standardized virtually all math accents by using combining marks. One problem with using the combining marks in file formats is that they, well, combine! So, it may be difficult to see them as separate entities unless you insert a nobreak space (U+00A0) or space (U+0020) in front of them. UnicodeMath allows a nobreak space to appear between the base and accent since UnicodeMath is used as an input format as well as in files. Only programmers need to look at most file formats (HTML, MathML, OMML, RTF), so a reliable standard is more important for file formats than userfriendly presentation.
MathML 3’s operator dictionary defines most horizontal arrows with the “accent” property. In addition, it defines the following accents
02C6 ˆ modifier letter circumflex accent
02C7 ˇ caron
02C9 ˉ modifier letter macron
02CA ˊ modifier letter acute accent
02CB ˋ modifier letter grave accent
02CD ˍ modifier letter low macron
02D8 ˘ breve
02D9 ˙ dot above
02DA ˚ ring above
02DC ˜ small tilde
02DD ˝ double acute accent
02F7 ˷ modifier letter low tilde
0302 ̂ combining circumflex accent
0311 ̑ combining inverted breve
Presumably the operator dictionary should be extended to include more math combining marks and their equivalents, if they exist, with the spacing diacritics in the range U+02C6..U+02DD.
Here’s the MathML for the math object 𝑎̂.
<mml:mover accent="true">
mm<mml:mi>a</mml:mi>
mm<mml:mo>^</mml:mo>
</mml:mover>
“Office MathML” OMML is the XML used in Microsoft Office file formats to represent most math. It’s an XML version of the inmemory math object model which differs from MathML. The math accent object 𝑎̂ has the following OMML
<m:acc>
mm<m:accPr>
mmmm<m:chr m:val=" ̂"/>
mmmm<m:ctrlPr/>
mm</m:accPr>
mm<m:e>
mmmm<m:r>
mmmmmm<m:t>𝑎</m:t>
mmmm</m:r>
mm</m:e>
</m:acc>
The Rich Text Format (RTF) represents math zones essentially as OMML written in RTF syntax. Regular RTF uses the \uN notation for Unicode characters not in the current code page. The math accent object 𝑎̂ has the RTF
{\macc{\maccPr{\mctrlPr\i\f0\fs20 }{\mchr \u770? }}{\me\i\u10187?\u9138?}}
Unicode RTF is easier to read since characters are written in Unicode
{\macc{\maccPr{\mctrlPr\i\f0\fs20 }{\mchr ̂}}{\me\i 𝑎}}
But none of these is as simple as the UnicodeMath 𝑎 ̂ ☺.
]]>
The RTF specification doesn’t have a control word for GIF images, although it has \jpegblib for jpeg’s and \pngblip for png’s. One way to persist GIFs would be to define a \gifblip. But this approach has the disadvantages that RTF readers that don’t recognize \gifblip would either discard the image altogether or fall back to an alternate format if one is included in the RTF stream. RichEdit’s earlier choice of converting the GIF to a png saves only the initial frame. A simple observation reveals how to solve both problems: the RTF reader isn’t, and furthermore shouldn’t be, responsible for the image format. Instead the program that interprets the image binary data should recognize the image format and validate the data. This is essential for security reasons. Accordingly, RichEdit just uses the \pngblip control word for a GIF even though the binary data defines a GIF! This interoperates with Word, older RichEdit clients, etc. Human readers of RTF can know the difference if they want to by looking at the image data, which starts with “PNG” for a real png and “GIF” for a GIF. The decoding of the images on Microsoft and Android operating systems is performed by the Windows Imaging Component (WIC), which also validates the images. Currently the RichEdit image facility isn’t supported on Apple platforms, but that may change.
When reading a GIF from RTF or via one of the APIs, RichEdit calls WIC to convert the image to a WIC bitmap. RichEdit saves memory space by not storing the original image data, since that data can be faithfully recovered from the WIC bitmap including all metadata.
Animated GIFs vary appreciably in size, ranging from 50 kilobytes for simple cartoon animation like
to several megabytes, such as this 1megabyte GIF from the movie Singin’ in the Rain
When exported in RTF files, the size doubles since each binary byte is represented by two hexadecimal bytes. So, it’s wise not to insert animated GIFs excessively.
The GIF format is described very well on the web, but here are a few quick thoughts before explaining how GIF animation works in RichEdit. First, GIF metadata is essential for animation. It controls the frame rate on a perframe basis, the color palette(s) and how the current full image is used in composing the next image. In fact, several partial frames along with the current full image may be combined to create the next displayed frame. Such intermediate frames have “0delay”, that is, they are included in the composition without being displayed. Some programs display them anyway (see the Windows photo viewer and the animated GIF sample), but I, at least ☺, think that’s misunderstanding the purpose of 0delay intermediate frames. In fact as discussed further below, some multiframe GIFs use the extra frames purely for refining the image colors, since a single frame is limited to 8bit color and one color palette.
Each animated GIF gets its own timer in this model since use of a shared timer ends up slowing down the animations. The time delays between frames may be the same or they can vary substantially, such as in the GIF
Animation is enabled/disabled via calling ITextDocument2::SetProperty(tomAnimateImages, Value), where tomAnimateImages is given by 0x95 and Value = tomTrue/tomFalse, respectively. A client that enables animation guarantees that the ID2D1RenderTarget supplied in the call to ITextServices2::TxDrawD2D() remain valid between calls. By default, animations are disabled since previous clients don’t know about this requirement.
Animations only work in Direct2D/DirectWrite mode. Initial attempts to get them running in GDI/Uniscribe mode display the animated images correctly except with a black background. This could be fixed if there is a need for animations in GDI mode.
Animations are disabled for selected images. This allows the user to recognize when images are selected. They are also disabled when the RichEdit control loses the focus. If a GIF has a maximum loop count, the animation stops after reaching that count.
Clients can get an image IStream by calling ITextRange::GetEmbeddedObject() to get the image’s IUnknown interface, then calling IUnknown::QueryInterface for an IServiceProvider interface and finally calling IServiceProvider::QueryService() to get the image IStream. This works for all kinds of images, not just GIFs.
GIFs with frames that all have zero frame delays display only the composite final frame. The multiple frames are typically used to get a composite image that has higherresolution color than possible with a single 8bit color palette. The Windows photo viewer nevertheless tries to animate such GIFs so the user sees fluctuating colors. PowerPoint presentation mode displays the correct composite image after one animation sequence, but Word only shows the first frame. See HighColor GIF Images for a detailed discussion of the following stationary multiframe GIF with highresolution color.
]]>Word’s current help facility does not document the EQ field, although it works as designed. In case you need to know more about the EQ field, this post gives documentation adapted from earlier Word help files.
Up until this month, a user could convert an EQ field into an Equation Editor OLE object. But starting this month, that is not possible since the Equation Editor is no longer available due to security concerns. See Error when editing an equation in Office for further information. One work around is that MathType can convert an EQ field into a MathType object. If you’ve been using the Equation Editor, it’s very worthwhile to install MathType. You can download MathType for free with the full features for 30 days and after that it still has more features than the Equation Editor, as well as being uptodate security wise. Alternatively, you might want to check out https://0patch.blogspot.com/2018/01/bringingabandonedequationeditorback.html. Even with that approach, it’s not easy to restore the Equation Editor since you have to reinstall the original eqnedt files and edit the registry.
Word help does document most fields such as SaveDate. To insert a field using Word’s ribbon, click on Insert/Quick Parts/Field…, which brings up a dialog. Scrolling down to Eq and clicking on Field Codes and then on Options, you can see
The options dialog lists the switches along with a brief description. It doesn’t give any switch options, at least some of which are needed for all but the most basic arithmetic. Once an EQ field is inserted, you can use the Toggle Field Codes contextmenu option to toggle back and forth between displaying the builtup equation and the linear {EQ…} text. In the latter, you can insert Unicode math alphanumerics and add spacing to improve the typography (see examples in Other Office Math Editing Facilities). The EQ field examples in this post don’t have these enhancements.
The EQ field produces mathematical expressions given by the switches. The switches specify how to build the equation with the elements, which are enclosed in parentheses. You can modify the behavior of a switch by following it with one or more switch options. A switch consists of a backslash (\) followed by a single letter. An option consists of a backslash followed by two letters and sometimes a number. Either EQ or eq can be used.
Some switches take a list of elements separated by commas or semicolons. Use commas as the separators if the decimal symbol for your system is a period. If the decimal symbol for your system is a comma, use semicolons.
To use a comma, open parenthesis, or backslash character in a resulting equation, precede the symbol with a backslash: \, \( \\.
Switch  Action 
array: \a()  Draw a twodimensional array 
bracket: \b()  Bracket a single element 
displace: \d()  Move next character to left or right a specified number of points 
fraction: \f(,)  Create a fraction 
integral: \i(,,)  Create an integral, summation or product using the specified symbol or default symbol and three elements 
list: \l()  Group values in a list, which can then be used as a single element 
overstrike: \o()  Display each successive element on top of the previous one 
radical: \r(,)  Draw a radical sign, using one or two elements 
superscript or subscript: \s()  Position elements as superscripts or subscripts 
box: \x()  Draw a border around an element 
The following sections describe each of these switches along with their options. The spaces shown in the tables between the options and the numeric value n are present only for readability; they can be omitted. In the switch examples, the linear native math zones are given in UnicodeMath. Typing the UnicodeMath text into a math zone (type alt+= to insert a math zone) and then ctrl+= converts it to the builtup (Professional) display to the right of the UnicodeMath.
Display an array (matrix) of elements in multiple columns. The elements appear in order by rows. The following options modify the \a switch
Option..  Action 
\al  Align left within columns 
\ac  Align center within columns 
\ar  Align right within columns 
\co n  Array elements in n columns (default is 1) 
\vs n  Add n points of vertical spacing between lines 
\hs n  Add n points of horizontal spacing between columns 
Example
{ EQ \a \ac \co2 \vs3 \hs3(Axy,Bxy,A,B) }  
\matrix(Axy&Bxy@A&B) 
Enclose an element with bracket(s) sized to fit the element. The default brackets are parentheses. The options listed in the following table can modify the \b switch.
Option..  Action 
\lc\c  Draw left bracket using the character c. 
\rc\c  Draw right bracket using the character c. 
\bc\c

Draw both bracket characters using the character specified for c. If the character you specify is {, [, (, or <, Word uses the corresponding closing character as the right bracket. If you specify any other character, Word uses that character for both brackets. 
Example
{ EQ \b \bc\{ (\r(3,x)) }  
{\sqrt(3&x)} 
Displace the next character according to the option(s) for the \d switch. The empty parentheses follow the last option. This switch doesn’t have a counterpart in native math zones, but Unicode spaces can be entered as desired in native math zones.
Option..  Action 
\fo n ()  Displace n points to the right 
\ba n ()  Displace n points to the left 
\li ()  Underline the space up to the next character 
Example
"Before { EQ \d \fo10 \li() } after" displays Before __ after
Create a fraction with the numerator centered over the denominator. If your system uses a comma as the decimal symbol, separate the two elements with a semicolon.
Example
{ EQ \f(2,RateChange) }  
2/"RateChange" 
Create an integral, summation or product using the specified symbol or default symbol and three elements. The first element is the lower limit, the second is the upper limit, and the third is the integrand, sum or product. The options listed in the following table modify the \i switch. By default the nary symbol is ∫.
Option..  Action 
\su  Change nary symbol to Σ and create a summation 
\pr  Change nary symbol to Π and create a product 
\in  Use inline formatting (display limits to right of the nary symbol instead of above and below) 
\fc\c  Substitute a fixedheight character specified by c for the nary symbol 
\vc\c  Substitute a variableheight character specified by c for the nary symbol. The symbol matches the height of the third element. 
Example
{ EQ \i \su(n=1,5,n) }  
\sum_(n=1)^5 n 
Create a list of elements separated by commas or semicolons, so that multiple elements act as a single element. Native math zones don’t need this construct.
Example
{ EQ \l(A,B,C,D,E) } displays A,B,C,D,E
Place each successive element on top of the previous one. Any number of elements is allowed. Separate multiple elements with commas. Each character is printed within an invisible character box. Options align the boxes on top of one another. This functionality can be obtained using the phantom operators (see Section 3.17 of the UnicodeMath specification) in native math zones. The following options modify the \o switch
Option..  Align character boxes 
\al  At left edge 
\ac  In the center (default) 
\ar  At right edge 
Example
{EQ \o(J,w) }  
\hsmash(J)w 
Draw a radical using one or two elements.
{ EQ \r(n,x) }  
\sqrt(n&x) 
Place an element or elements as superscript or subscript characters. Each \s code can have one or more elements; separate the elements with commas. If more than one element is specified, the elements are stacked and leftaligned. The following options place single elements after the \s switch
Option..  Action 
\ai n ()  Add n points of space above a line in a paragraph 
\up n ()  Move a single element above the baseline by n points. The default is 2 points 
\di n ()  Add n points of space below a line in a paragraph 
\do n ()  Move a single element below the baseline by n points. The default is 2 points 
Example
a{eq \s\do4(b{eq \s\do3(c)})}  
a_b_c 
Create a border for an element. When used without options, this switch draws a box around the element. The following options modify the \x switch
Switch..  Draws a border 
\to  above element 
\bo  below element 
\le  left of element 
\ri  right of element 
Example (Word currently ignores the 12& in the UnicodeMath, but its context menu lets you hide borders)
{ EQ \x \to \bo(5) }  
\rect(12&5) 
The arrangement of these examples is the {eq…} field on a line followed by a line with the corresponding UnicodeMath followed, in turn, by the builtup displays of the eq field and UnicodeMath. The symbol [boxed fn] can be entered by \funcapply (there are easier ways to type it and the integrals if one can use the → key)
{ eq \a\ac\vs1\co1(lim,n→∞) \b(\f(n,n^{2} + 1^{2}) + \f(n,n^{2} + 2^{2}) + ... + \f(n,n^{2} + n^{2}))}
lim_(n→∞) (n/(n^2+1^2 )+n/(n^2+2^2 )+…+n/(n^2+n^2 ))
..... 
{ eq \I(,, \b(\f(x,x^{2} + 3x + 2)))\s\up10(2)}
∫ (x/(x^2+3x+2))^2 dx
..... 
{ eq \i\in( tan x, \s\up2(sec x), \b(\r(3) )\s\up4(t)\s\up7(2) dt)}
\int_(tan x)^(sec x) (\sqrt 3)^𝑡^2
..... 
{ eq \b\bc\(\i\in( 0, 1,f(t) dt)  \i\su(k=0,n1,\f(1,2n) \b\bc\[(f\b(\f(k+1,n)) + f\b(\f(k,n))))) ≤ \f(M,12n²)}
\int_0^1\of f(t)dt\sum_(k=0)^(n1)\of\begin 1/2n [f(k+1/n)+f(k/n)]\end\leq M/12n^2
..... 
{ eq \b(\a\ac\vs2\hs2\col3(cos θ,sin θ, 0, sin θ, cos θ, 0, 0, 0, 1))\s\up20(n)}
(\matrix(cos θ&sin θ&0@sin θ&cos θ&0@0&0&1))^n
..... 
{ eq f(x) =\b\lc\{(\a\al\vs3\hs14\col2(x,if x>0,0,if x=0,x,if x<0)) }
f(x)=\cases(x &"if" x>0@0 &"if" x=0@x &"if" x<0)
..... 
{eq eq \o(\o(x,\s\do6(~)),\s\up5(^))}
x\hat\below~
..... 
]]>
Acetate selection is discussed in RichEdit Colors. The principle is that the background color of the selected text is blended with the selection background color and the text is then painted on top with the regular text color. This differs from other selection methods, such as inverting the colors of the selected text, using different selection text and background colors, or enclosing selected text in rectangles. Office applications typically use acetate selection, whereas Windows apps such as Notepad use selection text and background colors. One advantage of acetate selection for RichEdit is that partial ligature selection doesn’t get clipped by the rectangular selection background. This is illustrated in the following image where the f of an fi ligature is selected
Since the f’s text color doesn’t change when selected, the f’s underhang and overhang aren’t clipped. In contrast without acetate selection, RichEdit appears to select the whole fi ligature and clips the f’s underhang since RichEdit doesn’t have the code to render the ligature glyph three times with appropriate text colors. You can try out acetate selection with an Arabic ligature too, e.g., type a lam aleph (لا – gh with an Arabic keyboard) and then shift+→ to select the lam alone. You’ll see the acetate highlight go half way thru the لا. Acetate selection in RichEdit works the same way as in Word.
Without acetate selection as in Notepad, RichEdit can clip overhangs and underhangs. For example, with selection text and background colors and no ligatures, selecting the f alone renders as
Notepad displays this text without clipping. Acetate selection is used by default in RichEdit. To disable acetate selection, send EM_SETEDITSTYLEEX with wparam = lparam = SES_EX_NOACETATESELECTION.
Nevertheless, even with acetate selection, RichEdit will clip in some scenarios. If the character format of adjacent space differs from that of a character with an underhang, the selection can clip it. For example, selecting “f” in RichEdit where the f is in Times New Roman and the leading space is in Segoe UI looks like
The f overhang is also clipped if the character following the f is selected but not the f. For some scripts, RichEdit automatically formats spaces with the same font as the character that precedes it. But ideally the code should display such scenarios enough times to paint all parts of a glyph with the appropriate background. This problem doesn’t occur in Word or Notepad.
The source of the problem is that RichEdit handles one characterformat run at a time, first painting the background and then the text. When the format background changes, the new background gets painted over any overhang from the preceding run. A fix would be to paint all the background colors for a line first and then paint the text on top. Alternatively, one could paint a glyph as many times as necessary to display the various parts of the glyph unclipped (as in Notepad).
In wellformed typography, the baselines between different fonts coincide. This increases the line height when fonts with different ascents and descents appear on the same line. This is particularly true when Latin and Japanese scripts appear together. No one font can cover all of Unicode; Version 10 has 136,755 characters and TrueType fonts are limited to a maximum of 65535 glyphs (16bit glyph indices). So multiple fonts must be used in general. Notepad, too, uses multiple fonts to display such text. As such virtually any editor has to have some degree of richtext capability as discussed more in RichEdit PlainText Controls.
To illustrate how the line height increases when an East Asian font is used on the same line as a Latin font, we select text with a single font and then with a combination. The selection background color reveals the resulting line height
A way to avoid baseline alignment is to send the message EM_SETEDITSTYLEEX with wparam = lparam = SES_EX_DONTALIGNBASELINE (0x00000800). This flag isn’t currently defined in MSDN, but should be. For the example above, this choice produces
which fits in the same vertical space as the Latin text alone.
Some Southeast Asian scripts can have glyph size or shaping that results in a large ascent and/or descent. This can make it hard to mix with other scripts and maintain the line height. Accordingly, font designers may leave little or no vertical padding for glyph clusters that push the limits. In singleline controls or when paragraph linespacingexactly is active, this may result in clipping. For example, consider the Thai character SARA AI MAIMUAN ใ (U+0E43). Enlarging it and showing the top and bottom glyph boundaries compared to the Latin letter A, we see that there’s no room for roundoff on the top
RichEdit clips the top of this letter unless there’s some paragraph spacebefore or linespacing exactly with enough extra vertical space. While space before/after can eliminate such clipping for a single line, inside a multiline paragraph, one has to use a large enough linespacingexactly value. One could argue that the font designers made a mistake by eliminating all vertical padding for these large glyphs, but text renderers now need to deal with it. This font nopadding “feature” differs from the high fonts used in mathematics and in fancy fonts, which can have ascents and descents appreciably larger than those for standard glyphs.
While RichEdit provides a way to disable baseline alignment and to specify a larger line height to avoid Southeast Asian large glyph clipping, it doesn’t handle all kinds of selection clipping. It would be desirable to fix the remaining selection clipping scenarios and to offer a mode where the line height is automatically increased to avoid clipping of large Southeast Asian glyphs in fonts that provide inadequate vertical padding.
]]>
The EQ field was added in an early version of Word and still works, although the user is responsible for math spacing and inserting the desired math symbols. Any Unicode characters can be used including the complete Unicode math set of 2310 characters. To enter an equation, click on Insert/Quick Parts/Field… and select Eq from the list. Click on Field Codes and the Options… button to see the possible math constructs, such as \F(,) for fraction. With alt+x’ing in the Unicode math symbols, adding spaces around the operators and using the Cambria Math font, one can insert the solution to the quadratic equation as
The EQ field for this is {EQ 𝑥 = \F(−𝑏 ± \R(,𝑏\S(2) − 4𝑎𝑐),2𝑎)} formatted with Cambria Math and Unicode math italic alphabetics for a, b, c, and x. You can toggle the EQ field between the math display and the field codes by rightclicking on the field and choosing “Toggle Field Codes”. Note that the math axis doesn't line up between the equal sign and the fraction bar. The display isn’t as typographically pretty as that of the Office math facility (type alt+= \quadratic<space><space>)
and it’s appreciably harder to use. Also, the superscript size for the square must be formatted explicitly. If you change the size of the formula, you have to reformat the superscript with an appropriate smaller size. The Office math facility automatically chooses superscript and subscript sizes appropriate for the base text. The EQ field doesn't support Nary expressions other than simple integrals, summations and products. Word represents ruby objects using EQ fields, although it uses LineServices in rendering them. Some documentation on EQ fields is given here.
MathType and its limited edition, the Equation Editor, made math entry easier and considerably more general than the EQ field by adding intuitive tool bars giving access to mathematical symbols and function templates. All common math constructs are supported, and the typography includes niceties such as automatic math spacing around operators and trig functions. You can download the current version of MathType and use it for free for 30 days. After that it goes into a “lite” version unless you pay $99. The lite version has advantages over the Equation Editor not the least of which is that it’s currently maintained.
Both MathType and the Equation Editor display the solution to the quadratic equation as This is easy to enter using hot keys or the templates on the template tool bar. You can also enter it by hand writing using the Math Input Panel which communicates with client apps via MathML.
On Windows and the Mac, MathType and the Equation Editor use embedded OLE objects for displaying and editing math text. As such they can be used by any programs that support OLE such as WordPad. For WordPad, click on Insert Object and choose Microsoft Equation 3.0. But OLE is only available on Win32 Windows and the Mac. Also, a program’s search and formatting commands don’t work with embedded OLE objects, while they do work with native Office math zones.
MathType incorporates the Unicode 2.0 math characters and adds many others in the Unicode Private Use Area (see the MTCode Encoding Tables). 364 characters have the math property in Unicode 2.0. This is considerably less than the 2310 math characters in the current Unicode Standard. Most of the characters in the MTCode Encoding Tables are in the current Unicode Standard, but there might be backward compatibility issues if MathType were to upgrade to that version of the standard. There are many math characters in the Unicode Standard that are not in MathType. I haven’t been able to enter such characters into MathType or the Equation Editor. Since these characters are not common, it’s not a major limitation. Chapter 6 of Creating Research and Scientific Documents with Microsoft Word describes both the native Office math facility discussed in many of this blog’s posts as well as MathType.
Now let’s consider how various math entities are represented in these math facilities and the file formats they support. The formats are Presentation MathML, OMML (Office MathML), RTF, [La]TeX, UnicodeMath, braille, and MathType. Math entities such as fractions and integrals have arguments. The number of arguments and the order in which they occur may differ between the representations. The MathType equation format is a binary format and is documented in detail in the MathType SDK. The discussion here is limited to what the templates reveal when one runs MathType and/or the Equation Editor.
All math formats have a numerator and a denominator for fractions and they occur in that order. The EQ field and math braille only have stacked fractions (numerator above denominator), but the other formats also have slashed, linear, and small fractions.
Math functions, such as trigonometric and log, have an explicit twoargument entity in OMML and RTF, but are handled by character formatting alone in the other formats. Having an object with two explicit arguments reveals the content better in the user interface and facilitates typographic refinements, such as precise spacing.
OMML, RTF and MathType have three arguments for Nary entities such as integral and summation, namely the upper and lower limits and the integrand or summand, which can be called Naryands. [La]TeX and braille only have the two limits. Presentation MathML doesn’t have an explicit Nary entity; instead it overloads other entities (msub, msup, msubsup, mover, munder, munderover) which don't have an Naryand. This is a shortcoming of Presentation MathML. The EQ field has integrals, summations and products with all three arguments. Limits can be placed as subscript/superscript or under/over. UnicodeMath defines the Naryand to be the first operand following the Nary operator and its limits (if present). MathType puts the Naryand before the limits, while the EQ field, OMML and RTF put it afterward since it follows the limits visually. Having it afterward makes navigating with arrow keys more natural. MathType traverses integrals and summations with the Tab key in visual order, but the left/right arrow keys bypass the limit arguments.
Subscript and superscript bases are not arguments in MathType, [La]TeX, braille or the EQ field. They are arguments in MathML, OMML and RTF. In UnicodeMath, the base is the variable, function name, number, or object immediately preceding the sub/sup operators. Knowing the base allows proper kerning of the base onto the script (superscript or subscript) as well as providing more exact semantics in interoperating with mathematical calculation engines. While the base can be determined algorithmically as in MathType, [La]TeX and UnicodeMath, having an explicit argument for it automatically gives it helpful shading in Office math zones and lends precision to the finegrained math speech needed for unambiguous editing of math using speech.
The EQ field has the \B() option which puts appropriately sized parentheses around its argument. It doesn’t allow for other kinds of delimiters, such as [] and {}. Also, it doesn’t have multiple argument expressions that size the argument dividers appropriately, such as in Dirac notation. The other formats have many delimiter options and can handle multiple arguments correctly.
]]>
Several letters have variant glyphs and both the regular and variant characters can occur in the same document with different meanings. In my papers on laser theory, I’ve used θ for the polar angle in spherical coordinates and ϑ for a complex mode coupling coefficient. The following table shows the Greek letters that have variants
Letter..  Unicode..  TeX..  Variant..  Unicode..  TeX 
ϵ  03F5  \epsilon  ε  03B5  \varepsilon 
θ  03B8  \theta  ϑ  03D1  \vartheta 
Θ  0398  \Theta  ϴ  03F4  \varTheta 
π  03C0  \pi  ϖ  03D6  \varpi 
ρ  03C1  \rho  ϱ  03F1  \varrho 
σ  03C3  \sigma  ς  03C2  \varsigma 
ϕ  03D5  \phi  φ  03C6  \varphi 
ε and φ are standard letters in the modern Greek alphabet, but they are variants in math text as shown in the table. This is the choice made by TeX back in the early 1980s and the math community depends on it. Up to Version 3.0, the Unicode Standard displayed ϕ for 03C6, but in 3.0 it was changed to conform with modern Greek usage as documented in Section 2.3.1 Representative Glyphs for Greek Phi of Unicode Technical Report #25 Unicode Support for Mathematics. Unicode 3.1 added ϵ (03F5).
In The TeXbook Appendix F, the uppercase upsilon \Upsilon appears with curvy arms as in the Cambria Math Υ for 03A5. But in the STIX math 2 font, 03A5 appears as an uppercase Latin Y, which isn’t useful for math. Recognizing that fact, Unicode 1.1 encoded 03D2 for the curvy arm glyph ϒ (which unfortunately looks like a Y here; the WordPress blog infrastructure doesn't allow font changes). It has the odd name GREEK UPSILON WITH HOOK SYMBOL. One should not take Unicode names too literally except as being unique identifiers. Until recently, Cambria Math had no glyph at 03D2, but now it’s defined and preferred for math. Admittedly uppercase and lowercase upsilons aren’t commonly used in math, but I anyhow used υ extensively in laser theory to represent complex frequencies such as γ + iω. Here γ is a decay rate and ω is a (real) frequency.
TeX only defines uppercase Greek letters that have glyphs distinct from the Latin alphabet, that is, ΓΔΘΛΞΠΣΥΦΨΩ with the notation \Gamma for Γ. Unicode and Office apps support all uppercase Greek letters using the TeX convention that the first letter is upper case as in \Alpha for Α (uppercase alpha) and. For math, Greek letters that look identical to Latin letters aren’t useful, since they’d be interpreted as Latin letters. Lowercase Greek letters are italicized by default, while uppercase Greek letters are upright by default. This convention also applies to ∂ (\partial—italicized) and ∇ (\nabla—not italicized).
[La]TeX has control words to change the math style of math letters, such as \mathbf{…}, which changes the letters … to bold face. Ironically that construct doesn’t affect Greek letters, probably an early omission, but now unchangeable for archival reasons. Unicode chose to encode the various math alphabets explicitly instead of using variation selectors. Section 2.2 of Unicode Technical Report #25 describes the mathematical alphabets in the Unicode Standard, which are contained mostly in the plane1 range U+1D400..U+1D7FF along with some characters in the Letterlike Symbols (U+2100..U+214F). Here is Table 2.1 listing the various math styles
Math Style  Characters from Basic Set..  Location 
plain (upright, serifed)  Latin, Greek and digits  BMP 
bold  Latin, Greek and digits  Plane 1 
italic  Latin and Greek  Plane 1* 
bold italic  Latin and Greek  Plane 1 
script (calligraphic)  Latin  Plane 1* 
bold script (calligraphic)..  Latin  Plane 1 
Fraktur  Latin  Plane 1* 
bold Fraktur  Latin  Plane 1 
doublestruck  Latin and digits  Plane 1* 
sansserif  Latin and digits  Plane 1 
sansserif bold  Latin, Greek and digits  Plane 1 
sansserif italic  Latin  Plane 1 
sansserif bold italic  Latin and Greek  Plane 1 
monospace  Latin and digits  Plane 1 
Here the * notes that some characters of the corresponding alphabet are located in the Unicode Letterlike Symbols block.
There’s no sans serif upright Greek alphabet, but LaTeX can display this math style. LaTeX can also display two script variations as described in the post Unicode Math Calligraphic Alphabets, while Unicode only has one. Accordingly, more Unicode math alphabets may be added in the future.
Nemeth braille can represent all the math Greek alphabets and variants as described in the post Nemeth Braille Alphanumerics and Unicode Math Alphanumerics.
]]>
Option  Value  s/g  Meaning 
tomUnicodeBiDi  0x00000001  s  Use Unicode BiDi algorithm for inserted text 
tomAdjustCRLF  0x00000001  g  If range start is inside multicode unit like CRLF, surrogate pair, etc., move to start of unit 
tomUseCRLF  0x00000002  g  Paragraph ends use CRLF (U+000D U+000A) 
tomTextize  0x00000004  g  Embedded objects export alt text; else U+FFFC 
tomAllowFinalEOP  0x00000008  g  If range includes final EOP, export it; else don’t 
tomUnlink  0x00000008  s  Disables link attributes if present 
tomUnhide  0x00000010  s  Disables hidden attribute if present 
tomFoldMathAlpha  0x00000010  g  Replace math alphanumerics with ASCII/Greek 
tomIncludeNumbering  0x00000040  g  Lists include bullets/numbering 
tomCheckTextLimit  0x00000020  s  Only insert up to text limit 
tomDontSelectText  0x00000040  s  After insertion, call Collapse(tomEnd) 
tomTranslateTableCell  0x00000080  g  Export spaces for table delimiters 
tomNoMathZoneBrackets  0x00000100  g  Used with tomConvertUnicodeMath and tomConvertTeX. Set discards math zone brackets 
tomLanguageTag  0x00001000  s/gg  Sets BCP47 language tag for range; gets tag 
tomConvertRTF  0x00002000  s/g  Set or get RTF 
tomGetTextForSpell  0x00008000  g  Export spaces for hidden/math text, table delims 
tomConvertMathML  0x00010000  s/g  Set or get MathML 
tomGetUtf16  0x00020000  g  Causes tomConvertRTF, etc. to get UTF16. SetText2 accepts 8bit or 16bit RTF 
tomConvertLinearFormat  0x00040000  s/g  Alias for tomConvertUnicodeMath 
tomConvertUnicodeMath  0x00040000  s/g  UnicodeMath 
tomConvertOMML  0x00080000  s/g  Office MathML 
tomConvertMask  0x00F00000  s/g  Mask for mutually exclusive modes 
tomConvertRuby  0x00100000  s  See Inserting and Getting Math Text… 
tomConvertTeX  0x00200000  s/g  See LaTeX Math in Office 
tomConvertMathSpeech  0x00300000  g  Math speech (English only here) 
tomConvertSpeechTokens  0x00400000  g  Simple Unicode and speech tokens 
tomConvertNemeth  0x00500000  s/g  Nemeth math braille in U+2800 block 
tomConvertNemethAscii  0x00600000  g  Corresponding ASCII braille 
tomConvertNemethNoItalic  0x00700000  g  Nemeth braille in U+2800 block w/o math italic 
tomConvertNemethDefinition  0x00800000  g  Finegrained speech in braille 
tomConvertCRtoLF  0x01000000  g  Plaintext paragraphs end with LF, not CRLF 
tomLaTeXDelim  0x02000000  g  Use LaTeX mathzone delimiters \(...\) inline, \[...\] display; else $...$, $$...$$. Set handles all 
Nonzero values within the mask defined by tomConvertMask (0x00F00000) are mutually exclusive, that is, they cannot be combined (OR’d) with one another. These options include setting text as UnicodeMath, [La]TeX (tomConvertTeX), and Nemeth math braille (tomConvertNemeth). You can set only one at a time. But other options can be OR’d in if desired.
A string bstr of Nemeth math braille coded in the Unicode range U+2800..U+283F can be inserted and built up by calling ITextRange2::SetText2(tomConvertNemeth, bstr). If the string is valid, you can get it back in any of the math formats including Nemeth math braille. For example, if you insert the string
⠹⠂⠌⠆⠨⠏⠼⠮⠰⠴⠘⠆⠨⠏⠐⠹⠨⠈⠈⠙⠨⠹⠌⠁⠬⠃⠀⠎⠊⠝⠀⠨⠹⠼⠀⠨⠅⠀⠹⠂⠌⠜⠁⠘⠆⠐⠤⠃⠘⠆⠐⠻⠼
you see
You can also input braille with a standard keyboard by typing a control word \braille assigned to the Unicode character U+24B7 (Ⓑ). (See LaTeX Math in Office for how to add commands to math autocorrect). The \braille command causes math input to accept braille input via a regular keyboard using the braille ASCII codes sometimes referred to as North American Braille Computer Codes. The character ~ (U+007E) disables this input mode. These braille codes are described in the post Nemeth Braille—the first math linear format and can be input using refreshable braille displays. Alternatively, such input can be automated by calling ITextSelection::TypeText(bstr). Just as in entering UnicodeMath, the equations build up on screen as soon as the math braille input becomes unambiguous. The implementation includes the math braille UI that cues the user where the insertion point is for unambiguous editing of math zones using braille. Note that as of this posting, the math braille facility isn’t hooked up to Narrator or other screen readers.
The tomConvertMathSpeech currently only gets math speech in English. Microsoft Office apps like Word, PowerPoint and OneNote deliver math speech in over 18 languages to the assistive technology (AT) program Narrator via the UIA ITextRangeProvider::GetText() function. Other ATs could also get math speech this way. Dictating (setting) math speech would be nice for both blind and sighted folks. Imagine, you can say a² + b² = c² faster than you can type it or write it! The SetText2(tomConvertMathSpeech, bstr) is ready to handle such input, but it’s not implemented yet anyhow.
]]>
Control words for symbols work in either input mode, for example, \alpha inserts α in both modes. So, there’s no need to change the input mode for symbol control words. Similarly, Unicode symbols like ∬ work in both input modes. The buildup engine supports Unicode LaTeX since the Office math facility was based on Unicode from the start. Note that UnicodeMath is defined in terms of Unicode symbols, not ASCIIletter control words, but the latter are supported by the input engine for ease of entry on standard keyboards. Onscreen keyboards may offer more direct ways of entering Unicode symbols.
If a math zone begins with a $, the input must be TeX or LaTeX, since $ has no special significance in UnicodeMath and Office apps use the mathzone character format effect to define math zones. But the user might not start with a $, so it’s worth handling other ways that distinguish the formats. The LaTeX mathzone start delimiters \[ and \( have useful meanings in UnicodeMath, namely to treat the [ and ( literally instead of treating them as autosizing buildup delimiters.
Some structure control words such as \frac and \binom are only defined in LaTeX and others like \matrix and \pmatrix are defined in both modes. The user pain enters when typing something like \frac{a}{b} in UnicodeMath mode. The {…} get built up as curly braced expressions and the \frac remains unchanged. No fraction results and the user may wonder what went wrong.
When the user types LaTeXonly structure control words like \frac or \binom in UnicodeMath input mode, it’s clear that LaTeX is intended and the user can be asked whether the input mode should switch to LaTeX. Similarly, structure control words valid in both input modes become unambiguous when the user types the argument start delimiter. For LaTeX the start delimiter is {, while for UnicodeMath it’s (. So, \matrix( must be UnicodeMath, while \matrix{ must be LaTeX. Note that LaTeX by design supports the original TeX controlword sequences like \matrix{…} as well as the LaTeX environments like \begin{matrix}…\end{matrix}. In UnicodeMath autobuildup mode, no build up occurs when the user types \matrix{, so it’s possible at that point to switch to LaTeX input without need for retyping.
Both input modes have \begin and \end, but in LaTeX these are environment control words followed by {, whereas in UnicodeMath they represent generic start/end delimiters for which curly braces would be superfluous. So as soon as the user types { following \begin or \end, a cue recommending a switch to LaTeX input mode can be displayed.
Math functions are also treated differently in LaTeX and in UnicodeMath. To enter the sine function in LaTeX, one types \sin, whereas in UnicodeMath, one just types sin. So, if a math function name is entered preceded by \, a cue recommending a switch to LaTeX input mode can be displayed. The Office math display engine needs to know the argument of a math function as well as the function name in order to insert the correct math spacing. LaTeX doesn’t have a formal way of defining the argument, although enclosing it in curly braces is a good idea. UnicodeMath has precise ways of defining the argument. This is also true for integrands of integrals and naryands of nary operators in general.
The input a^2+b^2=c^2 represents the same equation in either input mode, but a^10+b^10=c^10 represents a¹⁰ + b¹⁰ = c¹⁰ in UnicodeMath and a¹0 + b¹0 = c¹0 in LaTeX. It doesn’t seem possible to distinguish the user intent for such cases, but it’d be worth asking the user who types a^{ or a_{ whether to switch to LaTeX, since superscript and subscripts enclosed in curly braces aren’t common in mathematical expressions. Expressions involving exp{…} do occur, but it’s better typography to use exp{…} instead of raising e to a braced power.
Font control words like \mathbf{ are distinctly LaTeX. The TeX binomialcoefficient construct {n\choose k} doesn’t make sense in UnicodeMath (one would type n\choose k without the curly braces). But {n\atop might be used in UnicodeMath since {n\atop k} would build up as n over k (without a fraction bar) enclosed in {}. Admittedly this construct is unlikely since binomial coefficients appear in parentheses, not in curly braces.
We see that there are quite a few [La]TeX constructs that don’t make sense in UnicodeMath and can be used to query the user about switching from UnicodeMath input mode to LaTeX input mode. In addition, such LaTeXoriented control sequences could be handled directly in UnicodeMath mode. The math buildup engine in Microsoft Office uses the same operator and string stacks for both modes, so it’s fairly straightforward to treat constructs like \frac{…}{…}, \matrix{…}, \begin{matrix}…\end{matrix} directly in UnicodeMath mode. This might make math input more user friendly for people familiar with LaTeX. And it might facilitate migrating to the speedier, more mathematical UnicodeMath input mode. But it does compromise using the buildup engine as a UnicodeMath validator. To that end, if the buildup engine is modified to handle these LaTeX control sequences in UnicodeMath mode, it might be worth having a “strict” mode that would fail input with invalid UnicodeMath. In any event, builddown results are all in one format or the other, not in a mixture of the two.
]]>Formula autobuildup is disabled for LaTeX in Word since it needs some more work. Word adds two new hot keys 1) to build up (ctrl+=) a math zone and 2) to build down (shift+ctrl+=). The hot key alt+= inserts a math zone (or removes one).
Currently, it’s trickier to enable LaTeX in OneNote and PowerPoint since you need to define a new math autocorrect control word to change the input mode. Type alt+= to enter a math zone and on the math ribbon click on the lower right corner of the Tools section. This brings up the Equation Options dialog. Click on Math Autocorrect and in the Replace text box type \TeX and in the With text box type 24C9 alt+x to enter Ⓣ. From then on you can type \TeX<space> in a math zone to switch the input format from UnicodeMath to LaTeX in OneNote and PowerPoint. If you want, you can define \LF as 24C1 alt+x to enter Ⓛ. This control word switches back to UnicodeMath, which we used to call the Linear Format. Note that formula autobuildup is not disabled by default in PowerPoint and OneNote, so you can see how you like it.
Note that the math autocorrect control word \integral enters the modelocking equation
by building up the UnicodeMath text
1/2π ∫_0^2π▒ⅆθ/(a+b sin θ)=1/√(a^2b^2)
This won’t build up correctly if LaTeX input is enabled. For PowerPoint and OneNote, you can define your own mathautocorrect control words using LaTeX notation which will build up correctly when LaTeX is enabled. In LaTeX the modelocking equation is given by
\frac{1}{2\pi}\int_{0}^{2\pi}\frac{d\theta}{a+b\sin{\theta}}=\frac{1}{\sqrt{a^2b^2}}.
It might be tempting to autoswitch to UnicodeMath buildup if a controlword inserts text with Unicode characters above the ASCII range. But people will probably switch to XeTeX or some other Unicode enabled TeX dialect for which this simple heuristic wouldn’t apply. In fact, Unicode TeX builds up correctly in Office math apps. For example, you can build up
\frac1{2π}∫_0^{2π}\frac{dθ}{a+b\sin{θ}}=\frac1{√{a^2b^2}}
which is easier to read than the pure ASCII version above. You can insert many Unicode characters from the galleries in the math ribbon.
The LaTeX option supports all TeX control words appearing in Appendix B of the UnicodeMath spec. That includes many math operators, Greek letters, and various other symbols. The verbose LaTeX notations like \begin{equation} and \begin{matrix} aren’t supported, but the more concise TeX notations are supported, such as \matrix{…} and \pmatrix{…}. Fractions can be entered in the LaTeX form \frac{…}{…} or in the TeX form {…\over…}. \displaymath is implied if the math zone fills the hard/soft paragraph and currently it can’t be turned on in inline math zones. Unicode math alphanumerics can be entered using control words like \mathbf{}. As for UnicodeMath, you can toggle math bold and math italic using the bold and italic buttons on the Home ribbon. You can enter script, openface (double struck), and fraktur letters with control words like \scriptX, \doubleX, and \frakturX, respectively. For example, \scriptS enters as does \mathcal{S}. The article Linear format equations using UnicodeMath and LaTeX in Word contains a list of many supported control words.
More enhancements are likely to be offered in the future. For example, it would be nice to have a Unicode LaTeX builddown option since it’s much easier to read than pure ASCII LaTeX. Also, it’d be nice to offer a formula autobuildup option in Word since it’s easier to see what you’re typing when you don’t have to wade through myriad control words. But the current facility is a big step forward for folks who know LaTeX well.
]]>
First here’s how these features are revealed to sighted users. In all mathenabled Office apps, the innermost math argument containing the IP is lightly shaded and selected text has the same selection background color as text not in math zones. In PowerPoint and OneNote, the math object containing the IP is shaded a bit more lightly than the argument and if the IP isn’t in a math object, the whole math zone has this lighter shading. In Word, the math zone is enclosed in a boundary and the object containing the IP doesn’t have the lighter shading. The user always knows what kind of an argument is involved just by looking at the builtup (Professional) display. This information is also conveyed in math finegrained speech.
A refreshable braille display typically has a row of 40 or 80 8dot cells with the dots represented by small rounded pins that are raised by solenoids. The dots are arranged in two columns of four dots. The left column is numbered starting at the top 1, 2, 3, 7 and the right column is numbered starting from the top 4, 5, 6, 8. Like most braille codes, the Nemeth math code uses the dots 1 through 6. This leaves dots 7 and 8 for UI purposes, although dot 7 is occasionally used to indicate upper case. The Nemeth code precedes a letter with the capitalization indicator “⠠” (lone dot 6) to get uppercase letters, e.g., “⠠⠁” for “A” since “⠁” is the braille code for the letter a. So, we don’t use dot 7 to indicate upper case, at least in math zones.
The regular math braille display shows the whole math zone in braille, limited only by the number of display cells. This gives a lot of context to math braille, significantly more than math speech provides, but not as much as screen or paper.
Typically, selected text appears with both dots 7 and 8. So if “a” is selected, it appears as “⣁”. This approach seems well suited to math expressions as well.
We’re left with needing ways to identify a math zone and the insertion point and to highlight the innermost argument containing the IP if any. Braille displays don’t have multiple shading levels, only two extra dots! They also have hot keys.
The IP needs a cell by itself to stand out. As described in the post Text Insertion Point, the IP is in between two characters in rich text, although for plain text one can get away with thinking of the IP as being on top of the character that actually follows the IP. Builtup (Professional) math text is rich text notably because it has special display constructs, such as stacked fractions, multilevel subscripts and superscripts, integrals, matrices, etc. For this purpose (and perhaps others), dots 78 “⣀” comprise a simple, effective IP. Admittedly this is the same as a lone selected space, but it seems to be readily distinguishable since the user usually knows when something is selected versus having an IP and s/he can easily move the IP (or hit the IPidentification hot key coming up) to check if in doubt.
To reveal the innermost argument containing the IP, one can turn on dot 8 for the characters in that argument. This is similar to the argument shading used in regular displays. To illustrate this approach, consider the fraction 1/2π, which in builtup form is given by the Nemeth braille string “⠹⠂⠌⠆⠨⠏⠼”. If the IP precedes the 2 in the denominator, the braille display would have “⠹⠂⠌⣀⢆⢨⢏⠼”.
At first the dot 8 in the denominator cells here might be confusing, but it resolves ambiguities as to whether the IP “⣀” is inside or outside of a math object. This isn’t a serious problem with fractions since the fraction start, fraction bar, and fraction end appear as the explicit braille codes ⠹,⠌,⠼, respectively, although it’s always helpful to know when the IP is in a math argument. But consider the quantity a², which is given in Nemeth braille by “⠁⠃⠆”. In Office apps and MathML, superscripts are represented by two arguments, the base and the superscript. If the IP precedes the base, is the IP at the start of the base or at the start of the superscript object? That position is ambiguous without the dot 8 option. With dot 8, you can tell the difference: in “⣀⠁⠃⠆” the IP precedes the superscript object, while in “⣀⢁⠃⠆” the IP is inside the base in front of the “a”. Distinguishing these positions is essential for unambiguous editing of mathematical text.
Dot8 highlighting reveals when the IP is at the start or end of an argument or somewhere in between. But it doesn’t define what kind of argument. To get this kind of information on a braille display, it’s handy to have an IPidentification hot key that flashes the name of the argument containing the IP (or “math zone” if the IP isn’t inside an argument) onto the braille display. This name needs to be localized to the current user language, while the regular braille for the math zone is globalized by nature. For example in English, depending on where the IP is in a denominator, the hot key displays “start of denominator” (⠎⠞⠁⠗⠞⠀⠕⠋⠀⠙⠑⠝⠕⠍⠊⠝⠁⠞⠕⠗), “end of denominator” or just “denominator”. This is more informative than the corresponding math speech, which only announces the kind of argument when the IP is at the end of an argument, or the kind of math object when the IP is at the start of an object. This difference occurs because finegrained speech needs to say the character at the IP, whereas the math braille display continuously shows the characters around the IP, limited only by the number of display cells.
It might be worth having options to enable/disable dot8 highlighting according to user preference. Even without the dot8 highlighting, the user can resolve ambiguities by hitting the IPidentification hot key so some users might prefer to work with the simpler braille display.
Lastly, how do you reveal a math zone? If the IP is inside a mathobject argument, the presence of dot 8 is a good indicator. As described in the post Braille for Math Zones, math zones start with “⠸⠩” and end with “⠸⠱”. So, the start and end of a math zone are not ambiguous in math braille. In the Microsoft Office math representation, whether the IP at the start of a math zone is inside the math zone or outside is revealed by shading or the Word mathzone border, since the character position is the same for both cases. Ditto for the end of a math zone. I tried setting dot 8 for all cells in a math zone when the IP is in a math zone, but not inside an argument, but it seems too messy. So hopefully the math zone start and end delimiters will suffice; the user can hit the IPidentification hot key to find out whether the IP is in a math zone.
With these uses of dots 7 and 8 and the IPidentification hot key, you can edit virtually all levels of mathematics using a refreshable braille display in an interoperable way with sighted users. Pretty cool, eh?!
]]>