Pure HTML output for math macros.

[lyx.git] / src / insets / InsetFloat.cpp

diff --git a/src/insets/InsetFloat.cpp b/src/insets/InsetFloat.cpp
index d01449368407a4f6d18b61607bcfc5ab788a96c7..dfbd208c9f36cd0c3f2a54321a34e04db60859fc 100644 (file)
--- a/src/insets/InsetFloat.cpp
+++ b/src/insets/InsetFloat.cpp
@@ -27,6 +27,7 @@
 #include "FuncStatus.h"
 #include "LaTeXFeatures.h"
 #include "Lexer.h"
+#include "output_xhtml.h"
 #include "ParIterator.h"
 #include "TextClass.h"
 
@@ -38,6 +39,7 @@
 #include "frontends/Application.h"
 
 using namespace std;
+using namespace lyx::support;
 
 
 namespace lyx {
@@ -109,24 +111,17 @@ namespace lyx {
 //
 // Lgb
 
-
-InsetFloat::InsetFloat(Buffer * buf, string const & type)
-       : InsetCollapsable(buf), name_(from_utf8(type))
-{
-       setLabel(_("float: ") + floatName(type));
-       params_.type = type;
-}
-
-
-InsetFloat::~InsetFloat()
+//FIXME: why do we set in stone the type here?
+InsetFloat::InsetFloat(Buffer * buf, string params_str)
+       : InsetCollapsable(buf)
 {
-       hideDialogs("float", this);
+       string2params(params_str, params_);
 }
 
 
 docstring InsetFloat::name() const 
 { 
-       return "Float:" + name_; 
+       return "Float:" + from_utf8(params_.type);
 }
 
 
@@ -154,8 +149,11 @@ void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd)
                        params_.wide      = params.wide;
                        params_.sideways  = params.sideways;
                }
-
                setNewLabel();
+               if (params_.type != params.type) {
+                       params_.type = params.type;
+                       buffer().updateBuffer();
+               }
                break;
        }
 
@@ -194,10 +192,14 @@ bool InsetFloat::getStatus(Cursor & cur, FuncRequest const & cmd,
 }
 
 
-void InsetFloat::updateLabels(ParIterator const & it)
+void InsetFloat::updateBuffer(ParIterator const & it, UpdateType utype)
 {
        Counters & cnts =
                buffer().masterBuffer()->params().documentClass().counters();
+       if (utype == OutputUpdate) {
+               // counters are local to the float
+               cnts.saveLastCounter();
+       }
        string const saveflt = cnts.current_float();
        bool const savesubflt = cnts.isSubfloat();
 
@@ -212,17 +214,19 @@ void InsetFloat::updateLabels(ParIterator const & it)
        cnts.current_float(params().type);
        cnts.isSubfloat(subflt);
 
-       InsetCollapsable::updateLabels(it);
+       InsetCollapsable::updateBuffer(it, utype);
 
        //reset afterwards
        cnts.current_float(saveflt);
+       if (utype == OutputUpdate)
+               cnts.restoreLastCounter();
        cnts.isSubfloat(savesubflt);
 }
 
 
 void InsetFloatParams::write(ostream & os) const
 {
-       os << "Float " << type << '\n';
+       os << type << '\n';
 
        if (!placement.empty())
                os << "placement " << placement << "\n";
@@ -242,6 +246,7 @@ void InsetFloatParams::write(ostream & os) const
 void InsetFloatParams::read(Lexer & lex)
 {
        lex.setContext("InsetFloatParams::read");
+       lex >> type;
        if (lex.checkFor("placement"))
                lex >> placement;
        lex >> "wide" >> wide;
@@ -251,6 +256,7 @@ void InsetFloatParams::read(Lexer & lex)
 
 void InsetFloat::write(ostream & os) const
 {
+       os << "Float ";
        params_.write(os);
        InsetCollapsable::write(os);
 }
@@ -260,6 +266,11 @@ void InsetFloat::read(Lexer & lex)
 {
        params_.read(lex);
        InsetCollapsable::read(lex);
+       // check if the float type exists
+       if (buffer().params().documentClass().floats().typeExist(params_.type))
+               setLabel(_("float: ") + floatName(params_.type));
+       else
+               setLabel(bformat(_("ERROR: Unknown float type: %1$s"), from_utf8(params_.type)));
 }
 
 
@@ -281,31 +292,32 @@ void InsetFloat::validate(LaTeXFeatures & features) const
 }
 
 
-docstring InsetFloat::xhtml(odocstream & os, OutputParams const & rp) const
+docstring InsetFloat::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 {
        FloatList const & floats = buffer().params().documentClass().floats();
        Floating const & ftype = floats.getType(params_.type);
        string const & htmltype = ftype.htmlTag();
-       string const & htmlclass = ftype.htmlClass();
-       docstring const otag = 
-                       from_ascii("<" + htmltype + " class='float " + htmlclass + "'>\n");
-       docstring const ctag = from_ascii("</" + htmltype + ">\n");
-
-       odocstringstream out;
+       string const & attr = ftype.htmlAttrib();
 
-       out << otag;
-       docstring def = InsetText::xhtml(out, rp);
-       out << ctag;
+       odocstringstream ods;
+       XHTMLStream newxs(ods);
+       newxs << html::StartTag(htmltype, attr);
+       InsetText::XHTMLOptions const opts = 
+               InsetText::WriteLabel | InsetText::WriteInnerTag;
+       docstring deferred = InsetText::insetAsXHTML(newxs, rp, opts);
+       newxs << html::EndTag(htmltype);
 
        if (rp.inFloat == OutputParams::NONFLOAT)
                // In this case, this float needs to be deferred, but we'll put it
                // before anything the text itself deferred.
-               def = out.str() + '\n' + def;
+               deferred = ods.str() + '\n' + deferred;
        else 
                // In this case, the whole thing is already being deferred, so
                // we can write to the stream.
-               os << out.str();
-       return def;
+               // Note that things will already have been escaped, so we do not 
+               // want to escape them again.
+               xs << XHTMLStream::NextRaw() << ods.str();
+       return deferred;
 }
 
 
@@ -415,15 +427,6 @@ bool InsetFloat::insetAllowed(InsetCode code) const
 }
 
 
-bool InsetFloat::showInsetDialog(BufferView * bv) const
-{
-       if (!InsetText::showInsetDialog(bv))
-               bv->showDialog("float", params2string(params()),
-                       const_cast<InsetFloat *>(this));
-       return true;
-}
-
-
 void InsetFloat::setWide(bool w, bool update_label)
 {
        params_.wide = w;
@@ -495,8 +498,6 @@ void InsetFloat::string2params(string const & in, InsetFloatParams & params)
        Lexer lex;
        lex.setStream(data);
        lex.setContext("InsetFloat::string2params");
-       lex >> "float" >> "Float";
-       lex >> params.type; // We have to read the type here!
        params.read(lex);
 }
 
@@ -504,7 +505,6 @@ void InsetFloat::string2params(string const & in, InsetFloatParams & params)
 string InsetFloat::params2string(InsetFloatParams const & params)
 {
        ostringstream data;
-       data << "float" << ' ';
        params.write(data);
        return data.str();
 }