@@ -557,6 +557,44 @@ oMathElemToExps (OMathRun sty elems)
557557 else [TM.EStyled textType [TM.EIdentifier $ oMathRunElemsToString elems]]
558558oMathElemToExps (OMathRun _ _) = []
559559
560+oMathRunTextStyleToTextType :: OMathRunTextStyle -> Maybe TM.TextType
561+oMathRunTextStyleToTextType (Normal) = Just $ TM.TextNormal
562+oMathRunTextStyleToTextType (NoStyle) = Nothing
563+oMathRunTextStyleToTextType (Styled scr sty)
564+ | Just OBold <- sty
565+ , Just OSansSerif <- scr =
566+ Just $ TM.TextSansSerifBold
567+ | Just OBoldItalic <- sty
568+ , Just OSansSerif <- scr =
569+ Just $ TM.TextSansSerifBoldItalic
570+ | Just OBold <- sty
571+ , Just OScript <- scr =
572+ Just $ TM.TextBoldScript
573+ | Just OBold <- sty
574+ , Just OFraktur <- scr =
575+ Just $ TM.TextBoldFraktur
576+ | Just OItalic <- sty
577+ , Just OSansSerif <- scr =
578+ Just $ TM.TextSansSerifItalic
579+ | Just OBold <- sty =
580+ Just $ TM.TextBold
581+ | Just OItalic <- sty =
582+ Just $ TM.TextItalic
583+ | Just OMonospace <- scr =
584+ Just $ TM.TextMonospace
585+ | Just OSansSerif <- scr =
586+ Just $ TM.TextSansSerif
587+ | Just ODoubleStruck <- scr =
588+ Just $ TM.TextDoubleStruck
589+ | Just OScript <- scr =
590+ Just $ TM.TextDoubleStruck
591+ | Just OFraktur <- scr =
592+ Just $ TM.TextFraktur
593+ | Just OBoldItalic <- sty =
594+ Just $ TM.TextBoldItalic
595+ | otherwise = Nothing
596+
597+
560598oMathRunStyleToTextType :: OMathRunStyle -> Maybe TM.TextType
561599oMathRunStyleToTextType mrPr
562600 | Normal <- oMathRunTextStyle mrPr =
@@ -620,3 +658,241 @@ baseToExp' (Base mathElems) =
620658elemToExps :: NameSpaces -> Element -> Maybe [TM.Exp]
621659elemToExps ns element = oMathToExps <$> (elemToMath ns element)
622660
661+
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") >>=
667+ Just . head
668+ chr' = case chr of
669+ Just c -> c
670+ Nothing -> '\180' -- default to acute.
671+ baseExp <- findChild (elemName ns "m" "e") element >>=
672+ elemToBase ns >>=
673+ (return . baseToExp)
674+ 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 >>=
681+ (return . baseToExp)
682+ case pos of
683+ "top" -> Just [TM.EOver False baseExp (TM.ESymbol TM.Accent "\175")]
684+ "bot" -> Just [TM.EUnder False baseExp (TM.ESymbol TM.Accent "\818")]
685+ _ -> Nothing
686+elemToExps' ns element | isElem ns "m" "box" element = do
687+ baseExp <- findChild (elemName ns "m" "e") element >>=
688+ elemToBase ns >>=
689+ (return . baseToExp)
690+ return [baseExp]
691+elemToExps' ns element | isElem ns "m" "borderBox" element = do
692+ -- TODO: This needs to be "\\boxed" somehow.
693+ baseExp <- findChild (elemName ns "m" "e") element >>=
694+ elemToBase ns >>=
695+ (return . baseToExp)
696+ return [baseExp]
697+elemToExps' ns element | isElem ns "m" "d" element =
698+ let baseExps = mapMaybe
699+ (\e -> (elemToBase ns e >>= (return . baseToExp)))
700+ (elChildren element)
701+ inDelimExps = map Right baseExps
702+ dPr = findChild (elemName ns "m" "dPr") element
703+ begChr = dPr >>=
704+ findChild (elemName ns "m" "begChr") >>=
705+ findAttr (elemName ns "m" "val") >>=
706+ (\c -> if null c then (Just ' ') else (Just $ head c))
707+ sepChr = dPr >>=
708+ findChild (elemName ns "m" "sepChr") >>=
709+ findAttr (elemName ns "m" "val") >>=
710+ (\c -> if null c then (Just ' ') else (Just $ head c))
711+ endChr = dPr >>=
712+ findChild (elemName ns "m" "endChr") >>=
713+ findAttr (elemName ns "m" "val") >>=
714+ (\c -> if null c then (Just ' ') else (Just $ head c))
715+ beg = fromMaybe '(' begChr
716+ end = fromMaybe ')' endChr
717+ sep = fromMaybe '|' sepChr
718+ exps = intersperse (Left [sep]) inDelimExps
719+ in
720+ Just [TM.EDelimited [beg] [end] exps]
721+elemToExps' ns element | isElem ns "m" "eqArr" element =
722+ let bases = mapMaybe (elemToBaseNoAmpersand ns) (elChildren element)
723+ baseExps = map (\b -> [baseToExp' b]) bases
724+ in
725+ 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)
731+ 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 >>=
736+ (return . baseToExp)
737+ -- We need a string for the fname, but omml gives it to us as a
738+ -- series of oMath elems. We're going to filter out the oMathRuns,
739+ -- which should work for us most of the time.
740+ let fnameString = concatMap expToString $
741+ concat $ mapMaybe (elemToExps' ns) (elChildren fName)
742+ return [TM.EMathOperator fnameString, baseExp]
743+elemToExps' ns element | isElem ns "m" "groupChr" element = do
744+ let gPr = findChild (elemName ns "m" "groupChrPr") element
745+ chr = gPr >>=
746+ findChild (elemName ns "m" "chr") >>=
747+ findAttr (elemName ns "m" "val")
748+ 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 >>=
753+ (return . baseToExp)
754+ case pos of
755+ Just "top" ->
756+ let chr' = case chr of
757+ Just (c:_) -> c
758+ _ -> '\65079' -- default to overbrace
759+ in
760+ return [TM.EOver False baseExp (TM.ESymbol TM.Accent [chr'])]
761+ Just "bot" ->
762+ let chr' = case chr of
763+ Just (c:_) -> c
764+ _ -> '\65080' -- default to underbrace
765+ in
766+ return [TM.EUnder False baseExp (TM.ESymbol TM.Accent [chr'])]
767+ _ -> Nothing
768+elemToExps' ns element | isElem ns "m" "limLow" element = do
769+ baseExp <- findChild (elemName ns "m" "e") element
770+ >>= elemToBase ns
771+ >>= (return . baseToExp)
772+ limExp <- findChild (elemName ns "m" "lim") element
773+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
774+ >>= (return . TM.EGrouped)
775+ 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+ >>= (return . baseToExp)
780+ limExp <- findChild (elemName ns "m" "lim") element
781+ >>= (\e -> Just $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
782+ >>= (return . TM.EGrouped)
783+ return [TM.EOver True limExp baseExp]
784+elemToExps' ns element | isElem ns "m" "m" element =
785+ let rows = findChildren (elemName ns "m" "mr") element
786+ rowExps = map
787+ (\mr -> mapMaybe
788+ (\e -> (elemToBase ns e >>= return . baseToExp'))
789+ (elChildren mr))
790+ rows
791+ in
792+ 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
795+ naryChr = naryPr >>=
796+ findChild (elemName ns "m" "chr") >>=
797+ findAttr (elemName ns "m" "val")
798+ opChr = case naryChr of
799+ Just (c:_) -> c
800+ _ -> '\8747' -- default to integral
801+ 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 >>=
810+ (return . baseToExp)
811+ case limLoc of
812+ Just "undOvr" -> return [TM.EUnderover True
813+ (TM.ESymbol TM.Op [opChr])
814+ (TM.EGrouped subExps)
815+ (TM.EGrouped supExps)
816+ , baseExp]
817+ _ -> return [TM.ESubsup
818+ (TM.ESymbol TM.Op [opChr])
819+ (TM.EGrouped subExps)
820+ (TM.EGrouped supExps)
821+ , baseExp]
822+
823+elemToExps' ns element | isElem ns "m" "phant" element = do
824+ baseExp <- findChild (elemName ns "m" "e") element >>=
825+ elemToBase ns >>=
826+ (return . baseToExp)
827+ 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 >>=
833+ (return . baseToExp)
834+ return $ case degExps of
835+ [] -> [TM.ESqrt baseExp]
836+ 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 >>=
844+ (return . baseToExp)
845+ return [TM.ESubsup
846+ (TM.EIdentifier "")
847+ (TM.EGrouped subExps)
848+ (TM.EGrouped supExps)
849+ , baseExp]
850+elemToExps' ns element | isElem ns "m" "sSub" element = do
851+ baseExp <- findChild (elemName ns "m" "e") element >>=
852+ elemToBase ns >>=
853+ (return . baseToExp)
854+ subExps <- findChild (elemName ns "m" "sub") element >>=
855+ (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
856+ 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+ (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))
865+ 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+ (return . baseToExp)
870+ supExps <- findChild (elemName ns "m" "sup") element >>=
871+ (\e -> return $ concat $ mapMaybe (elemToExps' ns) (elChildren e))
872+ 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
875+ lit = mrPr >>=
876+ findChild (elemName ns "m" "lit") >>=
877+ findAttr (elemName ns "m" "val")
878+ txtSty = elemToOMathRunTextStyle ns element
879+ mrElems <- elemToOMathRunElems ns element
880+ return $ case oMathRunTextStyleToTextType txtSty of
881+ Nothing -> [TM.EIdentifier $ oMathRunElemsToString mrElems]
882+ Just textType ->
883+ case lit of
884+ Just "on" ->
885+ [TM.EText textType (oMathRunElemsToString mrElems)]
886+ _ ->
887+ [TM.EStyled textType [TM.EIdentifier $ oMathRunElemsToString mrElems]]
888+elemToExps' _ _ = Nothing
889+
890+expToString :: TM.Exp -> String
891+expToString (TM.ENumber s) = s
892+expToString (TM.EIdentifier s) = s
893+expToString (TM.EMathOperator s) = s
894+expToString (TM.ESymbol _ s) = s
895+expToString (TM.EText _ s) = s
896+expToString (TM.EGrouped exps) = concatMap expToString exps
897+expToString (TM.EStyled _ exps) = concatMap expToString exps
898+expToString _ = ""