Framework for math export exceptions. We can throw these if we find

something we don't know how to handle and fall back to images.

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@35024 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp
index ae9511051cae6ccd5029c8d0e7f7ffa3b4c0f452..46ebb31a3c690d071acd9cdf366a1a1cfb850710 100644 (file)
--- a/src/mathed/InsetMathHull.cpp
+++ b/src/mathed/InsetMathHull.cpp
@@ -1854,37 +1854,49 @@ int InsetMathHull::docbook(odocstream & os, OutputParams const & runparams) cons
 
 docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
 {
-       BufferParams::MathOutput mathtype = buffer().params().html_math_output;
+       BufferParams::MathOutput const mathtype = 
+               buffer().params().html_math_output;
        
+       bool success = false;
        // FIXME Eventually we would like to do this inset by inset.
-       switch (mathtype) {
-       case BufferParams::MathML: {
+       if (mathtype == BufferParams::MathML) {
                odocstringstream os;
                MathStream ms(os);
-               InsetMathGrid::mathmlize(ms);
-               if (getType() == hullSimple)
-                       xs << html::StartTag("math", 
-                             "xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
-               else 
-                       xs << html::StartTag("math", 
-                             "display=\"block\" xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
-               xs << XHTMLStream::NextRaw() 
-                  << os.str()
-                  << html::EndTag("math");
-               break;
-       } 
-       case BufferParams::HTML: {
+               try {
+                       InsetMathGrid::mathmlize(ms);
+                       success = true;
+               } catch (MathExportException const &) {}
+               if (success) {
+                       if (getType() == hullSimple)
+                               xs << html::StartTag("math", 
+                                                       "xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
+                       else 
+                               xs << html::StartTag("math", 
+                                                       "display=\"block\" xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
+                       xs << XHTMLStream::NextRaw() 
+                                << os.str()
+                                << html::EndTag("math");
+               }
+       } else if (mathtype == BufferParams::HTML) {
                odocstringstream os;
                HtmlStream ms(os);
-               InsetMathGrid::htmlize(ms);
-               string const tag = (getType() == hullSimple) ? "span" : "div";
-               xs << html::StartTag(tag, "class='formula'", true)
-                  << XHTMLStream::NextRaw()
-                  << os.str()
-                  << html::EndTag(tag);
-               break;
-       } 
-       case BufferParams::Images: {
+               try {
+                       InsetMathGrid::htmlize(ms);
+                       success = true;
+               } catch (MathExportException const &) {}
+               if (success) {
+                       string const tag = (getType() == hullSimple) ? "span" : "div";
+                       xs << html::StartTag(tag, "class='formula'", true)
+                                << XHTMLStream::NextRaw()
+                                << os.str()
+                                << html::EndTag(tag);
+               }
+       }
+       
+       // the logic here is ugly, but it's meant to mean: if we've failed with
+       // one of the earlier attempts OR the mathtype IS Image, then try to 
+       // export an image.
+       if (!success && mathtype != BufferParams::LaTeX) {
                loadPreview(docit_);
                graphics::PreviewImage const * pimage = preview_->getPreviewImage(buffer());
                if (pimage) {
@@ -1897,11 +1909,14 @@ docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
                        xs.cr();
                        // add the file to the list of files to be exported
                        op.exportdata->addExternalFile("xhtml", mathimg);
-                       break;
+                       success = true;
                }
-               LYXERR0("Unable to generate image. Falling through to LaTeX output.");
-       } 
-       case BufferParams::LaTeX: {
+       }
+       
+       // so we'll pass this test if we've failed everything else, or
+       // if mathtype was LaTeX, since we won't have entered any of the
+       // earlier branches
+       if (!success) {
                string const tag = (getType() == hullSimple) ? "span" : "div";
                // Unfortunately, we cannot use latexString() because we do not want
                // $...$ or whatever.
@@ -1920,7 +1935,6 @@ docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
                   << html::EndTag(tag);
                xs.cr();
        }
-       } // end switch
        return docstring();
 }
 

diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h
index 40b06a0ef0561d401c52840bd699a543e8043275..70fdf30ef63454ad57be4578969d5563d0ba24ce 100644 (file)
--- a/src/mathed/MathStream.h
+++ b/src/mathed/MathStream.h
@@ -262,6 +262,13 @@ public:
 };
 
 
+/// Throw MathExportException to signal that the attempt to export
+/// some math in the current format did not succeed. E.g., we can't
+/// export xymatrix as MathML, so that will throw, and we'll fall back
+/// to images.
+class MathExportException : public std::exception {};
+
+
 class MathStream {
 public:
        ///