Routines for calculating numerical labels for BibTeX citations.

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

diff --git a/src/insets/InsetFloat.cpp b/src/insets/InsetFloat.cpp
index d4271da7d0616d6fd5aa9c017c5905a32c6035ad..b6a67b067500fe916e6b3d8386d9394d14b61659 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"
 
@@ -110,10 +111,10 @@ namespace lyx {
 // Lgb
 
 
-InsetFloat::InsetFloat(Buffer const & buf, string const & type)
+InsetFloat::InsetFloat(Buffer * buf, string const & type)
        : InsetCollapsable(buf), name_(from_utf8(type))
 {
-       setLabel(_("float: ") + floatName(type, buf.params()));
+       setLabel(_("float: ") + floatName(type));
        params_.type = type;
 }
 
@@ -153,11 +154,9 @@ void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd)
                        params_.placement = params.placement;
                        params_.wide      = params.wide;
                        params_.sideways  = params.sideways;
-                       setWide(params_.wide, cur.buffer()->params(), false);
-                       setSideways(params_.sideways, cur.buffer()->params(), false);
                }
 
-               setNewLabel(cur.buffer()->params());
+               setNewLabel();
                break;
        }
 
@@ -183,13 +182,20 @@ bool InsetFloat::getStatus(Cursor & cur, FuncRequest const & cmd,
                flag.setEnabled(true);
                return true;
 
+       case LFUN_INSET_SETTINGS:
+               if (InsetCollapsable::getStatus(cur, cmd, flag)) {
+                       flag.setEnabled(flag.enabled() && !params_.subfloat);
+                       return true;
+               } else
+                       return false;
+
        default:
                return InsetCollapsable::getStatus(cur, cmd, flag);
        }
 }
 
 
-void InsetFloat::updateLabels(ParIterator const & it)
+void InsetFloat::updateLabels(ParIterator const & it, bool out)
 {
        Counters & cnts =
                buffer().masterBuffer()->params().documentClass().counters();
@@ -201,13 +207,13 @@ void InsetFloat::updateLabels(ParIterator const & it)
        // floats can only embed subfloats of their own kind
        if (subflt)
                params_.type = saveflt;
-       setSubfloat(subflt, buffer().params());
+       setSubfloat(subflt);
 
        // Tell to captions what the current float is
        cnts.current_float(params().type);
        cnts.isSubfloat(subflt);
 
-       InsetCollapsable::updateLabels(it);
+       InsetCollapsable::updateLabels(it, out);
 
        //reset afterwards
        cnts.current_float(saveflt);
@@ -276,39 +282,32 @@ void InsetFloat::validate(LaTeXFeatures & features) const
 }
 
 
-docstring InsetFloat::editMessage() const
-{
-       return _("Opened Float Inset");
-}
-
-
-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.htmlType().empty() ? 
-                       "div" : ftype.htmlType();
-       string const htmlclass = ftype.htmlClass().empty() ?
-                       "float-" + params_.type : ftype.htmlClass();
-       docstring const otag = 
-                       from_ascii("<" + htmltype + " class='float " + htmlclass + "'>\n");
-       docstring const ctag = from_ascii("</" + htmltype + ">\n");
+       string const & htmltype = ftype.htmlTag();
+       string const & attr = ftype.htmlAttrib();
 
-       odocstringstream out;
-
-       out << otag;
-       docstring def = InsetText::xhtml(out, rp);
-       out << ctag;
+       odocstringstream ods;
+       XHTMLStream newxs(ods);
+       newxs << StartTag(htmltype, attr);
+       InsetText::XHTMLOptions const opts = 
+               InsetText::WriteLabel | InsetText::WriteInnerTag;
+       docstring deferred = InsetText::insetAsXHTML(newxs, rp, opts);
+       newxs << 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;
 }
 
 
@@ -383,7 +382,7 @@ int InsetFloat::latex(odocstream & os, OutputParams const & runparams_in) const
 int InsetFloat::plaintext(odocstream & os, OutputParams const & runparams) const
 {
        os << '[' << buffer().B_("float") << ' '
-               << floatName(params_.type, buffer().params()) << ":\n";
+               << floatName(params_.type) << ":\n";
        InsetText::plaintext(os, runparams);
        os << "\n]";
 
@@ -405,9 +404,16 @@ int InsetFloat::docbook(odocstream & os, OutputParams const & runparams) const
 
 bool InsetFloat::insetAllowed(InsetCode code) const
 {
-       return code != FOOT_CODE
-           && code != MARGIN_CODE
-           && (code != FLOAT_CODE || !params_.subfloat);
+       // The case that code == FLOAT_CODE is handled in Text3.cpp, 
+       // because we need to know what type of float is meant.
+       switch(code) {
+       case WRAP_CODE:
+       case FOOT_CODE:
+       case MARGIN_CODE:
+               return false;
+       default:
+               return InsetCollapsable::insetAllowed(code);
+       }
 }
 
 
@@ -420,38 +426,38 @@ bool InsetFloat::showInsetDialog(BufferView * bv) const
 }
 
 
-void InsetFloat::setWide(bool w, BufferParams const & bp, bool update_label)
+void InsetFloat::setWide(bool w, bool update_label)
 {
        params_.wide = w;
        if (update_label)
-               setNewLabel(bp);
+               setNewLabel();
 }
 
 
-void InsetFloat::setSideways(bool s, BufferParams const & bp, bool update_label)
+void InsetFloat::setSideways(bool s, bool update_label)
 {
        params_.sideways = s;
        if (update_label)
-               setNewLabel(bp);
+               setNewLabel();
 }
 
 
-void InsetFloat::setSubfloat(bool s, BufferParams const & bp, bool update_label)
+void InsetFloat::setSubfloat(bool s, bool update_label)
 {
        params_.subfloat = s;
        if (update_label)
-               setNewLabel(bp);
+               setNewLabel();
 }
 
 
-void InsetFloat::setNewLabel(BufferParams const & bp)
+void InsetFloat::setNewLabel()
 {
        docstring lab = _("float: ");
 
        if (params_.subfloat)
                lab = _("subfloat: ");
 
-       lab += floatName(params_.type, bp);
+       lab += floatName(params_.type);
 
        if (params_.wide)
                lab += '*';