@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
3030Types and functions for conversion of OMML into TeXMath.
3131-}
3232
33−module Text.Pandoc.Readers.Docx.OMath ( elemToExps
33+module Text.Pandoc.Readers.Docx.OMath ( elemToExps
3434 ) where
3535
3636import Text.XML.Light
@@ -39,16 +39,19 @@ import Data.List (intersperse)
3939import qualified Text.TeXMath.Types as TM
4040import Control.Applicative ((<$>))
4141
42−type NameSpaces = [(String, String)]
43−
44−elemName :: NameSpaces -> String -> String -> QName
45−elemName ns prefix name = (QName name (lookup prefix ns) (Just prefix))
46−
47−isElem :: NameSpaces -> String -> String -> Element -> Bool
48−isElem ns prefix name element =
49− qName (elName element) == name &&
50− qURI (elName element) == (lookup prefix ns)
42+isElem :: String -> String -> Element -> Bool
43+isElem prefix name element =
44+ let qp = fromMaybe "" (qPrefix (elName element))
45+ in
46+ qName (elName element) == name &&
47+ qp == prefix
5148
49+hasElemName:: String -> String -> QName -> Bool
50+hasElemName prefix name qn =
51+ let qp = fromMaybe "" (qPrefix qn)
52+ in
53+ qName qn == name &&
54+ qp == prefix
5255
5356data OMath = OMath [OMathElem]
5457 deriving Show
@@ -143,15 +146,15 @@ data GroupStyle = GroupStyle { groupChr :: Maybe Char
143146defaultGroupStyle :: GroupStyle
144147defaultGroupStyle = GroupStyle {groupChr = Nothing, groupPos = Nothing}
145148
146−elemToMath :: NameSpaces -> Element -> Maybe OMath
147−elemToMath ns element | isElem ns "m" "oMath" element =
148− Just $ OMath $ mapMaybe (elemToMathElem ns) (elChildren element)
149−elemToMath _ _ = Nothing
149+elemToMath :: Element -> Maybe OMath
150+elemToMath element | isElem "m" "oMath" element =
151+ Just $ OMath $ mapMaybe (elemToMathElem) (elChildren element)
152+elemToMath _ = Nothing
150153
151−elemToBase :: NameSpaces -> Element -> Maybe Base
152−elemToBase ns element | isElem ns "m" "e" element =
153− Just $ Base $ mapMaybe (elemToMathElem ns) (elChildren element)
154−elemToBase _ _ = Nothing
154+elemToBase :: Element -> Maybe Base
155+elemToBase element | isElem "m" "e" element =
156+ Just $ Base $ mapMaybe (elemToMathElem) (elChildren element)
157+elemToBase _ = Nothing
155158
156159-- TODO: The right way to do this is to use the ampersand to break the
157160-- text lines into multiple columns. That's tricky, though, and this
@@ -164,38 +167,38 @@ filterAmpersand (OMathRun mrPr elems) =
164167 OMathRun mrPr (map f elems)
165168filterAmpersand e = e
166169
167−elemToBaseNoAmpersand :: NameSpaces -> Element -> Maybe Base
168−elemToBaseNoAmpersand ns element | isElem ns "m" "e" element =
170+elemToBaseNoAmpersand :: Element -> Maybe Base
171+elemToBaseNoAmpersand element | isElem "m" "e" element =
169172 return $ Base $
170173 mapMaybe
171− (\e -> (elemToMathElem ns e >>= (return . filterAmpersand)))
174+ (\e -> (elemToMathElem e >>= (return . filterAmpersand)))
172175 (elChildren element)
173−elemToBaseNoAmpersand _ _ = Nothing
176+elemToBaseNoAmpersand _ = Nothing
174177
175−elemToOMathRunStyle :: NameSpaces -> Element -> OMathRunStyle
176−elemToOMathRunStyle ns element =
178+elemToOMathRunStyle :: Element -> OMathRunStyle
179+elemToOMathRunStyle element =
177180 let lit =
178181 case
179− findChild (elemName ns "m" "lit") element >>=
180− findAttr (elemName ns "m" "val")
182+ filterChildName (hasElemName"m" "lit") element >>=
183+ findAttrBy (hasElemName"m" "val")
181184 of
182185 Just "on" -> True
183186 _ -> False
184187 in
185188 OMathRunStyle { oMathLit = lit
186− , oMathRunTextStyle = (elemToOMathRunTextStyle ns element)
189+ , oMathRunTextStyle = (elemToOMathRunTextStyle element)
187190 }
188191
189−elemToOMathRunTextStyle :: NameSpaces -> Element -> OMathRunTextStyle
190−elemToOMathRunTextStyle ns element
191− | Just mrPr <- findChild (elemName ns "m" "rPr") element
192− , Just _ <- findChild (elemName ns "m" "nor") mrPr =
192+elemToOMathRunTextStyle :: Element -> OMathRunTextStyle
193+elemToOMathRunTextStyle element
194+ | Just mrPr <- filterChildName (hasElemName"m" "rPr") element
195+ , Just _ <- filterChildName (hasElemName"m" "nor") mrPr =
193196 Normal
194− | Just mrPr <- findChild (elemName ns "m" "rPr") element =
197+ | Just mrPr <- filterChildName (hasElemName"m" "rPr") element =
195198 let scr =
196199 case
197− findChild (elemName ns "m" "scr") mrPr >>=
198− findAttr (elemName ns "m" "val")
200+ filterChildName (hasElemName"m" "scr") mrPr >>=
201+ findAttrBy (hasElemName"m" "val")
199202 of
200203 Just "roman" -> Just ORoman
201204 Just "script" -> Just OScript
@@ -207,8 +210,8 @@ elemToOMathRunTextStyle ns element
207210
208211 sty =
209212 case
210− findChild (elemName ns "m" "sty") mrPr >>=
211− findAttr (elemName ns "m" "val")
213+ filterChildName (hasElemName"m" "sty") mrPr >>=
214+ findAttrBy (hasElemName"m" "val")
212215 of
213216 Just "p" -> Just OPlain
214217 Just "b" -> Just OBold
@@ -221,192 +224,192 @@ elemToOMathRunTextStyle ns element
221224
222225
223226
224−elemToNAryStyle :: NameSpaces -> Element -> NAryStyle
225−elemToNAryStyle ns element
226− | Just narypr <- findChild (QName "naryPr" (lookup "m" ns) (Just "m")) element =
227+elemToNAryStyle :: Element -> NAryStyle
228+elemToNAryStyle element
229+ | Just narypr <- filterChildName (hasElemName"m" "naryPr") element =
227230 let
228− chr = findChild (QName "chr" (lookup "m" ns) (Just "m")) narypr >>=
229− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
231+ chr = filterChildName (hasElemName"m" "chr") narypr >>=
232+ findAttrBy (hasElemName"m" "val") >>=
230233 Just . head
231− limLoc = findChild (QName "limLoc" (lookup "m" ns) (Just "m")) narypr >>=
232− findAttr (QName "val" (lookup "m" ns) (Just "m"))
234+ limLoc = filterChildName (hasElemName"m" "limLoc") narypr >>=
235+ findAttrBy (hasElemName"m" "val")
233236 limLoc' = case limLoc of
234237 Just "undOver" -> UnderOver
235238 Just "subSup" -> SubSup
236239 _ -> SubSup
237240 in
238241 NAryStyle { nAryChar = chr, nAryLimLoc = limLoc'}
239−elemToNAryStyle _ _ = defaultNAryStyle
242+elemToNAryStyle _ = defaultNAryStyle
240243
241−elemToDelimStyle :: NameSpaces -> Element -> DelimStyle
242−elemToDelimStyle ns element
243− | Just dPr <- findChild (QName "dPr" (lookup "m" ns) (Just "m")) element =
244− let begChr = findChild (QName "begChr" (lookup "m" ns) (Just "m")) dPr >>=
245− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
244+elemToDelimStyle :: Element -> DelimStyle
245+elemToDelimStyle element
246+ | Just dPr <- filterChildName (hasElemName"m" "dPr") element =
247+ let begChr = filterChildName (hasElemName"m" "begChr") dPr >>=
248+ findAttrBy (hasElemName"m" "val") >>=
246249 (\c -> if null c then (Just ' ') else (Just $ head c))
247− sepChr = findChild (QName "sepChr" (lookup "m" ns) (Just "m")) dPr >>=
248− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
250+ sepChr = filterChildName (hasElemName"m" "sepChr") dPr >>=
251+ findAttrBy (hasElemName"m" "val") >>=
249252 (\c -> if null c then (Just ' ') else (Just $ head c))
250− endChr = findChild (QName "endChr" (lookup "m" ns) (Just "m")) dPr >>=
251− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
253+ endChr = filterChildName (hasElemName"m" "endChr") dPr >>=
254+ findAttrBy (hasElemName"m" "val") >>=
252255 (\c -> if null c then (Just ' ') else (Just $ head c))
253256 in
254257 DelimStyle { delimBegChar = begChr
255258 , delimSepChar = sepChr
256259 , delimEndChar = endChr}
257−elemToDelimStyle _ _ = defaultDelimStyle
260+elemToDelimStyle _ = defaultDelimStyle
258261
259−elemToGroupStyle :: NameSpaces -> Element -> GroupStyle
260−elemToGroupStyle ns element
261− | Just gPr <- findChild (QName "groupChrPr" (lookup "m" ns) (Just "m")) element =
262− let chr = findChild (QName "chr" (lookup "m" ns) (Just "m")) gPr >>=
263− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
262+elemToGroupStyle :: Element -> GroupStyle
263+elemToGroupStyle element
264+ | Just gPr <- filterChildName (hasElemName"m" "groupChrPr") element =
265+ let chr = filterChildName (hasElemName"m" "chr") gPr >>=
266+ findAttrBy (hasElemName"m" "val") >>=
264267 Just . head
265− pos = findChild (QName "pos" (lookup "m" ns) (Just "m")) gPr >>=
266− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
268+ pos = filterChildName (hasElemName"m" "pos") gPr >>=
269+ findAttrBy (hasElemName"m" "val") >>=
267270 (\s -> Just $ if s == "top" then Top else Bottom)
268271 in
269272 GroupStyle { groupChr = chr, groupPos = pos }
270−elemToGroupStyle _ _ = defaultGroupStyle
273+elemToGroupStyle _ = defaultGroupStyle
271274
272−elemToMathElem :: NameSpaces -> Element -> Maybe OMathElem
273−elemToMathElem ns element | isElem ns "m" "acc" element = do
275+elemToMathElem :: Element -> Maybe OMathElem
276+elemToMathElem element | isElem "m" "acc" element = do
274277 let accChar =
275− findChild (elemName ns "m" "accPr") element >>=
276− findChild (elemName ns "m" "chr") >>=
277− findAttr (elemName ns "m" "val") >>=
278+ filterChildName (hasElemName"m" "accPr") element >>=
279+ filterChildName (hasElemName"m" "chr") >>=
280+ findAttrBy (hasElemName"m" "val") >>=
278281 Just . head
279282 accPr = AccentStyle { accentChar = accChar}
280− base <- findChild (elemName ns "m" "e") element >>=
281− elemToBase ns
283+ base <- filterChildName (hasElemName"m" "e") element >>=
284+ elemToBase
282285 return $ Accent accPr base
283−elemToMathElem ns element | isElem ns "m" "bar" element = do
284− barPr <- findChild (QName "barPr" (lookup "m" ns) (Just "m")) element >>=
285− findChild (QName "pos" (lookup "m" ns) (Just "m")) >>=
286− findAttr (QName "val" (lookup "m" ns) (Just "m")) >>=
286+elemToMathElem element | isElem "m" "bar" element = do
287+ barPr <- filterChildName (hasElemName"m" "barPr") element >>=
288+ filterChildName (hasElemName"m" "pos") >>=
289+ findAttrBy (hasElemName"m" "val") >>=
287290 (\s ->
288291 Just $ BarStyle {
289292 barPos = (if s == "bot" then Bottom else Top)
290293 })
291− base <- findChild (QName "e" (lookup "m" ns) (Just "m")) element >>=
292− elemToBase ns
294+ base <- filterChildName (hasElemName"m" "e") element >>=
295+ elemToBase
293296 return $ Bar barPr base
294−elemToMathElem ns element | isElem ns "m" "box" element =
295− findChild (elemName ns "m" "e") element >>=
296− elemToBase ns >>=
297+elemToMathElem element | isElem "m" "box" element =
298+ filterChildName (hasElemName"m" "e") element >>=
299+ elemToBase >>=
297300 (\b -> return $ Box b)
298−elemToMathElem ns element | isElem ns "m" "borderBox" element =
299− findChild (elemName ns "m" "e") element >>=
300− elemToBase ns >>=
301+elemToMathElem element | isElem "m" "borderBox" element =
302+ filterChildName (hasElemName"m" "e") element >>=
303+ elemToBase >>=
301304 (\b -> return $ BorderBox b)
302−elemToMathElem ns element | isElem ns "m" "d" element =
303− let style = elemToDelimStyle ns element
305+elemToMathElem element | isElem "m" "d" element =
306+ let style = elemToDelimStyle element
304307 in
305− return $ Delimiter style $ mapMaybe (elemToBase ns) (elChildren element)
306−elemToMathElem ns element | isElem ns "m" "eqArr" element =
307− return $ EquationArray $ mapMaybe (elemToBaseNoAmpersand ns) (elChildren element)
308−elemToMathElem ns element | isElem ns "m" "f" element = do
309− num <- findChild (elemName ns "m" "num") element
310− den <- findChild (elemName ns "m" "den") element
311− let numElems = mapMaybe (elemToMathElem ns) (elChildren num)
312− denElems = mapMaybe (elemToMathElem ns) (elChildren den)
308+ return $ Delimiter style $ mapMaybe (elemToBase) (elChildren element)
309+elemToMathElem element | isElem "m" "eqArr" element =
310+ return $ EquationArray $ mapMaybe (elemToBaseNoAmpersand) (elChildren element)
311+elemToMathElem element | isElem "m" "f" element = do
312+ num <- filterChildName (hasElemName"m" "num") element
313+ den <- filterChildName (hasElemName"m" "den") element
314+ let numElems = mapMaybe (elemToMathElem) (elChildren num)
315+ denElems = mapMaybe (elemToMathElem) (elChildren den)
313316 return $ Fraction numElems denElems
314−elemToMathElem ns element | isElem ns "m" "func" element = do
315− fName <- findChild (elemName ns "m" "fName") element
316− base <- findChild (elemName ns "m" "e") element >>=
317− elemToBase ns
318− let fnElems = mapMaybe (elemToMathElem ns) (elChildren fName)
317+elemToMathElem element | isElem "m" "func" element = do
318+ fName <- filterChildName (hasElemName"m" "fName") element
319+ base <- filterChildName (hasElemName"m" "e") element >>=
320+ elemToBase
321+ let fnElems = mapMaybe (elemToMathElem) (elChildren fName)
319322 return $ Function fnElems base
320−elemToMathElem ns element | isElem ns "m" "groupChr" element =
321− let style = elemToGroupStyle ns element
323+elemToMathElem element | isElem "m" "groupChr" element =
324+ let style = elemToGroupStyle element
322325 in
323− findChild (elemName ns "m" "e") element >>=
324− elemToBase ns >>=
326+ filterChildName (hasElemName"m" "e") element >>=
327+ elemToBase >>=
325328 (\b -> return $ Group style b)
326−elemToMathElem ns element | isElem ns "m" "limLow" element = do
327− base <- findChild (elemName ns "m" "e") element
328− >>= elemToBase ns
329− lim <- findChild (elemName ns "m" "lim") element
330− let limElems = mapMaybe (elemToMathElem ns) (elChildren lim)
329+elemToMathElem element | isElem "m" "limLow" element = do
330+ base <- filterChildName (hasElemName"m" "e") element
331+ >>= elemToBase
332+ lim <- filterChildName (hasElemName"m" "lim") element
333+ let limElems = mapMaybe (elemToMathElem) (elChildren lim)
331334 return $ LowerLimit base limElems
332−elemToMathElem ns element | isElem ns "m" "limUpp" element = do
333− base <- findChild (elemName ns "m" "e") element
334− >>= elemToBase ns
335− lim <- findChild (elemName ns "m" "lim") element
336− let limElems = mapMaybe (elemToMathElem ns) (elChildren lim)
335+elemToMathElem element | isElem "m" "limUpp" element = do
336+ base <- filterChildName (hasElemName"m" "e") element
337+ >>= elemToBase
338+ lim <- filterChildName (hasElemName"m" "lim") element
339+ let limElems = mapMaybe (elemToMathElem) (elChildren lim)
337340 return $ UpperLimit base limElems
338−elemToMathElem ns element | isElem ns "m" "m" element = do
339− let rows = findChildren (elemName ns "m" "mr") element
340− let bases = mapMaybe (\mr -> mapM (elemToBase ns) (elChildren mr)) rows
341+elemToMathElem element | isElem "m" "m" element = do
342+ let rows = filterChildrenName (hasElemName"m" "mr") element
343+ let bases = mapMaybe (\mr -> mapM (elemToBase) (elChildren mr)) rows
341344 return $ Matrix bases
342−elemToMathElem ns element | isElem ns "m" "nary" element = do
343− let style = elemToNAryStyle ns element
344− sub <- findChild (elemName ns "m" "sub") element >>=
345− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
346− sup <- findChild (elemName ns "m" "sup") element >>=
347− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
348− base <- findChild (elemName ns "m" "e") element >>=
349− elemToBase ns
345+elemToMathElem element | isElem "m" "nary" element = do
346+ let style = elemToNAryStyle element
347+ sub <- filterChildName (hasElemName"m" "sub") element >>=
348+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
349+ sup <- filterChildName (hasElemName"m" "sup") element >>=
350+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
351+ base <- filterChildName (hasElemName"m" "e") element >>=
352+ elemToBase
350353 return $ NAry style sub sup base
351−elemToMathElem ns element | isElem ns "m" "rad" element = do
352− deg <- findChild (elemName ns "m" "deg") element >>=
353− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
354− base <- findChild (elemName ns "m" "e") element >>=
355− elemToBase ns
354+elemToMathElem element | isElem "m" "rad" element = do
355+ deg <- filterChildName (hasElemName"m" "deg") element >>=
356+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
357+ base <- filterChildName (hasElemName"m" "e") element >>=
358+ elemToBase
356359 return $ Radical deg base
357−elemToMathElem ns element | isElem ns "m" "phant" element = do
358− base <- findChild (elemName ns "m" "e") element >>=
359− elemToBase ns
360+elemToMathElem element | isElem "m" "phant" element = do
361+ base <- filterChildName (hasElemName"m" "e") element >>=
362+ elemToBase
360363 return $ Phantom base
361−elemToMathElem ns element | isElem ns "m" "sPre" element = do
362− sub <- findChild (elemName ns "m" "sub") element >>=
363− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
364− sup <- findChild (elemName ns "m" "sup") element >>=
365− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
366− base <- findChild (elemName ns "m" "e") element >>=
367− elemToBase ns
364+elemToMathElem element | isElem "m" "sPre" element = do
365+ sub <- filterChildName (hasElemName"m" "sub") element >>=
366+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
367+ sup <- filterChildName (hasElemName"m" "sup") element >>=
368+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
369+ base <- filterChildName (hasElemName"m" "e") element >>=
370+ elemToBase
368371 return $ PreSubSuper sub sup base
369−elemToMathElem ns element | isElem ns "m" "sSub" element = do
370− base <- findChild (elemName ns "m" "e") element >>=
371− elemToBase ns
372− sub <- findChild (elemName ns "m" "sub") element >>=
373− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
372+elemToMathElem element | isElem "m" "sSub" element = do
373+ base <- filterChildName (hasElemName"m" "e") element >>=
374+ elemToBase
375+ sub <- filterChildName (hasElemName"m" "sub") element >>=
376+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
374377 return $ Sub base sub
375−elemToMathElem ns element | isElem ns "m" "sSubSup" element = do
376− base <- findChild (elemName ns "m" "e") element >>=
377− elemToBase ns
378− sub <- findChild (elemName ns "m" "sub") element >>=
379− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
380− sup <- findChild (elemName ns "m" "sup") element >>=
381− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
378+elemToMathElem element | isElem "m" "sSubSup" element = do
379+ base <- filterChildName (hasElemName"m" "e") element >>=
380+ elemToBase
381+ sub <- filterChildName (hasElemName"m" "sub") element >>=
382+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
383+ sup <- filterChildName (hasElemName"m" "sup") element >>=
384+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
382385 return $ SubSuper base sub sup
383−elemToMathElem ns element | isElem ns "m" "sSup" element = do
384− base <- findChild (elemName ns "m" "e") element >>=
385− elemToBase ns
386− sup <- findChild (elemName ns "m" "sup") element >>=
387− (\e -> return $ mapMaybe (elemToMathElem ns) (elChildren e))
386+elemToMathElem element | isElem "m" "sSup" element = do
387+ base <- filterChildName (hasElemName"m" "e") element >>=
388+ elemToBase
389+ sup <- filterChildName (hasElemName"m" "sup") element >>=
390+ (\e -> return $ mapMaybe (elemToMathElem) (elChildren e))
388391 return $ Super base sup
389−elemToMathElem ns element | isElem ns "m" "r" element = do
390− let mrPr = elemToOMathRunStyle ns element
391− mrElems <- elemToOMathRunElems ns element
392+elemToMathElem element | isElem "m" "r" element = do
393+ let mrPr = elemToOMathRunStyle element
394+ mrElems <- elemToOMathRunElems element
392395 return $ OMathRun mrPr mrElems
393−elemToMathElem _ _ = Nothing
394−
395−elemToOMathRunElem :: NameSpaces -> Element -> Maybe OMathRunElem
396−elemToOMathRunElem ns element
397− | isElem ns "w" "t" element
398− || isElem ns "m" "t" element
399− || isElem ns "w" "delText" element = Just $ TextRun $ strContent element
400− | isElem ns "w" "br" element = Just LnBrk
401− | isElem ns "w" "tab" element = Just Tab
396+elemToMathElem _ = Nothing
397+
398+elemToOMathRunElem :: Element -> Maybe OMathRunElem
399+elemToOMathRunElem element
400+ | isElem "w" "t" element
401+ || isElem "m" "t" element
402+ || isElem "w" "delText" element = Just $ TextRun $ strContent element
403+ | isElem "w" "br" element = Just LnBrk
404+ | isElem "w" "tab" element = Just Tab
402405 | otherwise = Nothing
403406
404−elemToOMathRunElems :: NameSpaces -> Element -> Maybe [OMathRunElem]
405−elemToOMathRunElems ns element
406− | isElem ns "w" "r" element
407− || isElem ns "m" "r" element =
408− Just $ mapMaybe (elemToOMathRunElem ns) (elChildren element)
409−elemToOMathRunElems _ _ = Nothing
407+elemToOMathRunElems :: Element -> Maybe [OMathRunElem]
408+elemToOMathRunElems element
409+ | isElem "w" "r" element
410+ || isElem "m" "r" element =
411+ Just $ mapMaybe (elemToOMathRunElem) (elChildren element)
412+elemToOMathRunElems _ = Nothing
410413
411414----- And now the TeXMath Creation
412415
@@ -655,62 +658,62 @@ baseToExp' :: Base -> [TM.Exp]
655658baseToExp' (Base mathElems) =
656659 concatMap oMathElemToExps mathElems
657660
658−elemToExps :: NameSpaces -> Element -> Maybe [TM.Exp]
659−elemToExps ns element = oMathToExps <$> (elemToMath ns element)
661+elemToExps :: Element -> Maybe [TM.Exp]
662+elemToExps element = oMathToExps <$> (elemToMath element)
660663
661664
662−elemToExps' :: NameSpaces -> Element -> Maybe [TM.Exp]
663−elemToExps' ns element | isElem ns "m" "acc" element = do
664− let chr = findChild (elemName ns "m" "accPr") element >>=
665− findChild (elemName ns "m" "chr") >>=
666− findAttr (elemName ns "m" "val") >>=
665+elemToExps' :: Element -> Maybe [TM.Exp]
666+elemToExps' element | isElem "m" "acc" element = do
667+ let chr = filterChildName (hasElemName "m" "accPr") element >>=
668+ filterChildName (hasElemName "m" "chr") >>=
669+ findAttrBy (hasElemName "m" "val") >>=
667670 Just . head
668671 chr' = case chr of
669672 Just c -> c
670673 Nothing -> '\180' -- default to acute.
671− baseExp <- findChild (elemName ns "m" "e") element >>=
672− elemToBase ns >>=
674+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
675+ elemToBase >>=
673676 (return . baseToExp)
674677 return $ [TM.EOver False baseExp (TM.ESymbol TM.Accent [chr'])]
675−elemToExps' ns element | isElem ns "m" "bar" element = do
676− pos <- findChild (elemName ns "m" "barPr") element >>=
677− findChild (elemName ns "m" "pos") >>=
678− findAttr (elemName ns "m" "val")
679− baseExp <- findChild (elemName ns "m" "e") element >>=
680− elemToBase ns >>=
678+elemToExps' element | isElem "m" "bar" element = do
679+ pos <- filterChildName (hasElemName "m" "barPr") element >>=
680+ filterChildName (hasElemName "m" "pos") >>=
681+ findAttrBy (hasElemName "m" "val")
682+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
683+ elemToBase >>=
681684 (return . baseToExp)
682685 case pos of
683686 "top" -> Just [TM.EOver False baseExp (TM.ESymbol TM.Accent "\175")]
684687 "bot" -> Just [TM.EUnder False baseExp (TM.ESymbol TM.Accent "\818")]
685688 _ -> Nothing
686−elemToExps' ns element | isElem ns "m" "box" element = do
687− baseExp <- findChild (elemName ns "m" "e") element >>=
688− elemToBase ns >>=
689+elemToExps' element | isElem "m" "box" element = do
690+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
691+ elemToBase >>=
689692 (return . baseToExp)
690693 return [baseExp]
691−elemToExps' ns element | isElem ns "m" "borderBox" element = do
694+elemToExps' element | isElem "m" "borderBox" element = do
692695 -- TODO: This needs to be "\\boxed" somehow.
693− baseExp <- findChild (elemName ns "m" "e") element >>=
694− elemToBase ns >>=
696+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
697+ elemToBase >>=
695698 (return . baseToExp)
696699 return [baseExp]
697−elemToExps' ns element | isElem ns "m" "d" element =
700+elemToExps' element | isElem "m" "d" element =
698701 let baseExps = mapMaybe
699− (\e -> (elemToBase ns e >>= (return . baseToExp)))
702+ (\e -> (elemToBase e >>= (return . baseToExp)))
700703 (elChildren element)
701704 inDelimExps = map Right baseExps
702− dPr = findChild (elemName ns "m" "dPr") element
705+ dPr = filterChildName (hasElemName "m" "dPr") element
703706 begChr = dPr >>=
704− findChild (elemName ns "m" "begChr") >>=
705− findAttr (elemName ns "m" "val") >>=
707+ filterChildName (hasElemName "m" "begChr") >>=
708+ findAttrBy (hasElemName "m" "val") >>=
706709 (\c -> if null c then (Just ' ') else (Just $ head c))
707710 sepChr = dPr >>=
708− findChild (elemName ns "m" "sepChr") >>=
709− findAttr (elemName ns "m" "val") >>=
711+ filterChildName (hasElemName "m" "sepChr") >>=
712+ findAttrBy (hasElemName "m" "val") >>=
710713 (\c -> if null c then (Just ' ') else (Just $ head c))
711714 endChr = dPr >>=
712− findChild (elemName ns "m" "endChr") >>=
713− findAttr (elemName ns "m" "val") >>=
715+ filterChildName (hasElemName "m" "endChr") >>=
716+ findAttrBy (hasElemName "m" "val") >>=
714717 (\c -> if null c then (Just ' ') else (Just $ head c))
715718 beg = fromMaybe '(' begChr
716719 end = fromMaybe ')' endChr
@@ -718,38 +721,38 @@ elemToExps' ns element | isElem ns "m" "d" element =
718721 exps = intersperse (Left [sep]) inDelimExps
719722 in
720723 Just [TM.EDelimited [beg] [end] exps]
721−elemToExps' ns element | isElem ns "m" "eqArr" element =
722− let bases = mapMaybe (elemToBaseNoAmpersand ns) (elChildren element)
724+elemToExps' element | isElem "m" "eqArr" element =
725+ let bases = mapMaybe (elemToBaseNoAmpersand) (elChildren element)
723726 baseExps = map (\b -> [baseToExp' b]) bases
724727 in
725728 return [TM.EArray [] baseExps]
726−elemToExps' ns element | isElem ns "m" "f" element = do
727− num <- findChild (elemName ns "m" "num") element
728− den <- findChild (elemName ns "m" "den") element
729− let numExp = TM.EGrouped $ concat $ mapMaybe (elemToExps' ns) (elChildren num)
730− denExp = TM.EGrouped $ concat $ mapMaybe (elemToExps' ns) (elChildren den)
729+elemToExps' element | isElem "m" "f" element = do
730+ num <- filterChildName (hasElemName "m" "num") element
731+ den <- filterChildName (hasElemName "m" "den") element
732+ let numExp = TM.EGrouped $ concat $ mapMaybe (elemToExps') (elChildren num)
733+ denExp = TM.EGrouped $ concat $ mapMaybe (elemToExps') (elChildren den)
731734 return $ [TM.EFraction TM.NormalFrac numExp denExp]
732−elemToExps' ns element | isElem ns "m" "func" element = do
733− fName <- findChild (elemName ns "m" "fName") element
734− baseExp <- findChild (elemName ns "m" "e") element >>=
735− elemToBase ns >>=
735+elemToExps' element | isElem "m" "func" element = do
736+ fName <- filterChildName (hasElemName "m" "fName") element
737+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
738+ elemToBase >>=
736739 (return . baseToExp)
737740 -- We need a string for the fname, but omml gives it to us as a
738741 -- series of oMath elems. We're going to filter out the oMathRuns,
739742 -- which should work for us most of the time.
740743 let fnameString = concatMap expToString $
741− concat $ mapMaybe (elemToExps' ns) (elChildren fName)
744+ concat $ mapMaybe (elemToExps') (elChildren fName)
742745 return [TM.EMathOperator fnameString, baseExp]
743−elemToExps' ns element | isElem ns "m" "groupChr" element = do
744− let gPr = findChild (elemName ns "m" "groupChrPr") element
746+elemToExps' element | isElem "m" "groupChr" element = do
747+ let gPr = filterChildName (hasElemName "m" "groupChrPr") element
745748 chr = gPr >>=
746− findChild (elemName ns "m" "chr") >>=
747− findAttr (elemName ns "m" "val")
749+ filterChildName (hasElemName "m" "chr") >>=
750+ findAttrBy (hasElemName "m" "val")
748751 pos = gPr >>=
749− findChild (elemName ns "m" "pos") >>=
750− findAttr (elemName ns "m" "val")
751− baseExp <- findChild (elemName ns "m" "e") element >>=
752− elemToBase ns >>=
752+ filterChildName (hasElemName "m" "pos") >>=
753+ findAttrBy (hasElemName "m" "val")
754+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
755+ elemToBase >>=
753756 (return . baseToExp)
754757 case pos of
755758 Just "top" ->
@@ -765,48 +768,48 @@ elemToExps' ns element | isElem ns "m" "groupChr" element = do
765768 in
766769 return [TM.EUnder False baseExp (TM.ESymbol TM.Accent [chr'])]
767770 _ -> Nothing
768−elemToExps' ns element | isElem ns "m" "limLow" element = do
769− baseExp <- findChild (elemName ns "m" "e") element
770− >>= elemToBase ns
771+elemToExps' element | isElem "m" "limLow" element = do
772+ baseExp <- filterChildName (hasElemName "m" "e") element
773+ >>= elemToBase
771774 >>= (return . baseToExp)
772− limExp <- findChild (elemName ns "m" "lim") element
773− >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
775+ limExp <- filterChildName (hasElemName "m" "lim") element
776+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps') (elChildren e))
774777 >>= (return . TM.EGrouped)
775778 return [TM.EUnder True limExp baseExp]
776−elemToExps' ns element | isElem ns "m" "limUpp" element = do
777− baseExp <- findChild (elemName ns "m" "e") element
778− >>= elemToBase ns
779+elemToExps' element | isElem "m" "limUpp" element = do
780+ baseExp <- filterChildName (hasElemName "m" "e") element
781+ >>= elemToBase
779782 >>= (return . baseToExp)
780− limExp <- findChild (elemName ns "m" "lim") element
781− >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
783+ limExp <- filterChildName (hasElemName "m" "lim") element
784+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps') (elChildren e))
782785 >>= (return . TM.EGrouped)
783786 return [TM.EOver True limExp baseExp]
784−elemToExps' ns element | isElem ns "m" "m" element =
785− let rows = findChildren (elemName ns "m" "mr") element
787+elemToExps' element | isElem "m" "m" element =
788+ let rows = filterChildrenName (hasElemName "m" "mr") element
786789 rowExps = map
787790 (\mr -> mapMaybe
788− (\e -> (elemToBase ns e >>= return . baseToExp'))
791+ (\e -> (elemToBase e >>= return . baseToExp'))
789792 (elChildren mr))
790793 rows
791794 in
792795 return [TM.EArray [TM.AlignCenter] rowExps]
793−elemToExps' ns element | isElem ns "m" "nary" element = do
794− let naryPr = findChild (elemName ns "m" "naryPr") element
796+elemToExps' element | isElem "m" "nary" element = do
797+ let naryPr = filterChildName (hasElemName "m" "naryPr") element
795798 naryChr = naryPr >>=
796− findChild (elemName ns "m" "chr") >>=
797− findAttr (elemName ns "m" "val")
799+ filterChildName (hasElemName "m" "chr") >>=
800+ findAttrBy (hasElemName "m" "val")
798801 opChr = case naryChr of
799802 Just (c:_) -> c
800803 _ -> '\8747' -- default to integral
801804 limLoc = naryPr >>=
802− findChild (elemName ns "m" "limLoc") >>=
803− findAttr (elemName ns "m" "val")
804− subExps <- findChild (elemName ns "m" "sub") element >>=
805− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
806− supExps <- findChild (elemName ns "m" "sup") element >>=
807− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
808− baseExp <- findChild (elemName ns "m" "e") element >>=
809− elemToBase ns >>=
805+ filterChildName (hasElemName "m" "limLoc") >>=
806+ findAttrBy (hasElemName "m" "val")
807+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
808+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
809+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
810+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
811+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
812+ elemToBase >>=
810813 (return . baseToExp)
811814 case limLoc of
812815 Just "undOvr" -> return [TM.EUnderover True
@@ -820,63 +823,63 @@ elemToExps' ns element | isElem ns "m" "nary" element = do
820823 (TM.EGrouped supExps)
821824 , baseExp]
822825
823−elemToExps' ns element | isElem ns "m" "phant" element = do
824− baseExp <- findChild (elemName ns "m" "e") element >>=
825− elemToBase ns >>=
826+elemToExps' element | isElem "m" "phant" element = do
827+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
828+ elemToBase >>=
826829 (return . baseToExp)
827830 return [TM.EPhantom baseExp]
828−elemToExps' ns element | isElem ns "m" "rad" element = do
829− degExps <- findChild (elemName ns "m" "deg") element >>=
830− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
831− baseExp <- findChild (elemName ns "m" "e") element >>=
832− elemToBase ns >>=
831+elemToExps' element | isElem "m" "rad" element = do
832+ degExps <- filterChildName (hasElemName "m" "deg") element >>=
833+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
834+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
835+ elemToBase >>=
833836 (return . baseToExp)
834837 return $ case degExps of
835838 [] -> [TM.ESqrt baseExp]
836839 ds -> [TM.ERoot (TM.EGrouped ds) baseExp]
837−elemToExps' ns element | isElem ns "m" "sPre" element = do
838− subExps <- findChild (elemName ns "m" "sub") element >>=
839− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
840− supExps <- findChild (elemName ns "m" "sup") element >>=
841− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
842− baseExp <- findChild (elemName ns "m" "e") element >>=
843− elemToBase ns >>=
840+elemToExps' element | isElem "m" "sPre" element = do
841+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
842+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
843+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
844+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
845+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
846+ elemToBase >>=
844847 (return . baseToExp)
845848 return [TM.ESubsup
846849 (TM.EIdentifier "")
847850 (TM.EGrouped subExps)
848851 (TM.EGrouped supExps)
849852 , baseExp]
850−elemToExps' ns element | isElem ns "m" "sSub" element = do
851− baseExp <- findChild (elemName ns "m" "e") element >>=
852− elemToBase ns >>=
853+elemToExps' element | isElem "m" "sSub" element = do
854+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
855+ elemToBase >>=
853856 (return . baseToExp)
854− subExps <- findChild (elemName ns "m" "sub") element >>=
855− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
857+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
858+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
856859 return [TM.ESub baseExp (TM.EGrouped subExps)]
857−elemToExps' ns element | isElem ns "m" "sSubSup" element = do
858− baseExp <- findChild (elemName ns "m" "e") element >>=
859− elemToBase ns >>=
860+elemToExps' element | isElem "m" "sSubSup" element = do
861+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
862+ elemToBase >>=
860863 (return . baseToExp)
861− subExps <- findChild (elemName ns "m" "sub") element >>=
862− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
863− supExps <- findChild (elemName ns "m" "sup") element >>=
864− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
864+ subExps <- filterChildName (hasElemName "m" "sub") element >>=
865+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
866+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
867+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
865868 return [TM.ESubsup baseExp (TM.EGrouped subExps) (TM.EGrouped supExps)]
866−elemToExps' ns element | isElem ns "m" "sSup" element = do
867− baseExp <- findChild (elemName ns "m" "e") element >>=
868− elemToBase ns >>=
869+elemToExps' element | isElem "m" "sSup" element = do
870+ baseExp <- filterChildName (hasElemName "m" "e") element >>=
871+ elemToBase >>=
869872 (return . baseToExp)
870− supExps <- findChild (elemName ns "m" "sup") element >>=
871− (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
873+ supExps <- filterChildName (hasElemName "m" "sup") element >>=
874+ (\e -> return $ concat $ mapMaybe (elemToExps') (elChildren e))
872875 return [TM.ESuper baseExp (TM.EGrouped supExps)]
873−elemToExps' ns element | isElem ns "m" "r" element = do
874− let mrPr = findChild (elemName ns "m" "rPr") element
876+elemToExps' element | isElem "m" "r" element = do
877+ let mrPr = filterChildName (hasElemName "m" "rPr") element
875878 lit = mrPr >>=
876− findChild (elemName ns "m" "lit") >>=
877− findAttr (elemName ns "m" "val")
878− txtSty = elemToOMathRunTextStyle ns element
879− mrElems <- elemToOMathRunElems ns element
879+ filterChildName (hasElemName "m" "lit") >>=
880+ findAttrBy (hasElemName "m" "val")
881+ txtSty = elemToOMathRunTextStyle element
882+ mrElems <- elemToOMathRunElems element
880883 return $ case oMathRunTextStyleToTextType txtSty of
881884 Nothing -> [TM.EIdentifier $ oMathRunElemsToString mrElems]
882885 Just textType ->
@@ -885,7 +888,7 @@ elemToExps' ns element | isElem ns "m" "r" element = do
885888 [TM.EText textType (oMathRunElemsToString mrElems)]
886889 _ ->
887890 [TM.EStyled textType [TM.EIdentifier $ oMathRunElemsToString mrElems]]
888−elemToExps' _ _ = Nothing
891+elemToExps' _ = Nothing
889892
890893expToString :: TM.Exp -> String
891894expToString (TM.ENumber s) = s