]> git.lyx.org Git - lyx.git/blobdiff - src/insets/InsetFloat.cpp
Routines for calculating numerical labels for BibTeX citations.
[lyx.git] / src / insets / InsetFloat.cpp
index 0ad25cf4100e01618a8cc39e2dc57b43e365cca5..b6a67b067500fe916e6b3d8386d9394d14b61659 100644 (file)
 #include "FloatList.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
-#include "InsetList.h"
 #include "LaTeXFeatures.h"
 #include "Lexer.h"
-#include "OutputParams.h"
+#include "output_xhtml.h"
 #include "ParIterator.h"
 #include "TextClass.h"
 
-#include "support/convert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
 #include "support/gettext.h"
@@ -113,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;
 }
 
@@ -135,7 +133,7 @@ docstring InsetFloat::name() const
 
 docstring InsetFloat::toolTip(BufferView const & bv, int x, int y) const
 {
-       if (InsetCollapsable::toolTip(bv, x, y).empty() || isOpen())
+       if (InsetCollapsable::toolTip(bv, x, y).empty() || isOpen(bv))
                return docstring();
 
        OutputParams rp(&buffer().params().encoding());
@@ -156,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;
        }
 
@@ -186,15 +182,23 @@ 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();
+       Counters & cnts =
+               buffer().masterBuffer()->params().documentClass().counters();
        string const saveflt = cnts.current_float();
        bool const savesubflt = cnts.isSubfloat();
 
@@ -203,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);
@@ -256,9 +260,6 @@ void InsetFloat::write(ostream & os) const
 void InsetFloat::read(Lexer & lex)
 {
        params_.read(lex);
-       setWide(params_.wide, buffer().params());
-       setSideways(params_.sideways, buffer().params());
-       setSubfloat(params_.subfloat, buffer().params());
        InsetCollapsable::read(lex);
 }
 
@@ -271,38 +272,66 @@ void InsetFloat::validate(LaTeXFeatures & features) const
        if (params_.sideways)
                features.require("rotfloat");
 
-       if (params_.subfloat)
+       if (features.inFloat())
                features.require("subfig");
 
-       features.useFloat(params_.type, params_.subfloat);
+       features.useFloat(params_.type, features.inFloat());
+       features.inFloat(true);
        InsetCollapsable::validate(features);
+       features.inFloat(false);
 }
 
 
-docstring InsetFloat::editMessage() const
+docstring InsetFloat::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 {
-       return _("Opened Float Inset");
+       FloatList const & floats = buffer().params().documentClass().floats();
+       Floating const & ftype = floats.getType(params_.type);
+       string const & htmltype = ftype.htmlTag();
+       string const & attr = ftype.htmlAttrib();
+
+       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.
+               deferred = ods.str() + '\n' + deferred;
+       else 
+               // In this case, the whole thing is already being deferred, so
+               // we can write to the stream.
+               // Note that things will already have been escaped, so we do not 
+               // want to escape them again.
+               xs << XHTMLStream::NextRaw() << ods.str();
+       return deferred;
 }
 
 
-int InsetFloat::latex(odocstream & os, OutputParams const & runparams) const
+int InsetFloat::latex(odocstream & os, OutputParams const & runparams_in) const
 {
-       if (params_.subfloat) {
-               if (runparams.moving_arg)
+       if (runparams_in.inFloat != OutputParams::NONFLOAT) {
+               if (runparams_in.moving_arg)
                        os << "\\protect";
                os << "\\subfloat";
        
-               OutputParams rp = runparams;
+               OutputParams rp = runparams_in;
                docstring const caption = getCaption(rp);
                if (!caption.empty()) {
                        os << caption;
                }
                os << '{';
-               int const i = InsetText::latex(os, runparams);
+               rp.inFloat = OutputParams::SUBFLOAT;
+               int const i = InsetText::latex(os, rp);
                os << "}";
        
                return i + 1;
        }
+       OutputParams runparams(runparams_in);
+       runparams.inFloat = OutputParams::MAINFLOAT;
 
        FloatList const & floats = buffer().params().documentClass().floats();
        string tmptype = params_.type;
@@ -353,7 +382,7 @@ int InsetFloat::latex(odocstream & os, OutputParams const & runparams) 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]";
 
@@ -375,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);
+       }
 }
 
 
@@ -390,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 )
+       if (params_.subfloat)
                lab = _("subfloat: ");
 
-       lab += floatName(params_.type, bp);
+       lab += floatName(params_.type);
 
        if (params_.wide)
                lab += '*';
@@ -438,47 +474,16 @@ docstring InsetFloat::getCaption(OutputParams const & runparams) const
        if (paragraphs().empty())
                return docstring();
 
-       ParagraphList::const_iterator pit = paragraphs().begin();
-       for (; pit != paragraphs().end(); ++pit) {
-               InsetList::const_iterator it = pit->insetList().begin();
-               for (; it != pit->insetList().end(); ++it) {
-                       Inset & inset = *it->inset;
-                       if (inset.lyxCode() == CAPTION_CODE) {
-                               odocstringstream ods;
-                               InsetCaption * ins =
-                                       static_cast<InsetCaption *>(it->inset);
-                               ins->getOptArg(ods, runparams);
-                               ods << '[';
-                               ins->getArgument(ods, runparams);
-                               ods << ']';
-                               return ods.str();
-                       }
-               }
-       }
-       return docstring();
-}
-
-
-docstring InsetFloat::getCaptionText(OutputParams const & runparams) const
-{
-       if (paragraphs().empty())
+       InsetCaption const * ins = getCaptionInset();
+       if (ins == 0)
                return docstring();
 
-       ParagraphList::const_iterator pit = paragraphs().begin();
-       for (; pit != paragraphs().end(); ++pit) {
-               InsetList::const_iterator it = pit->insetList().begin();
-               for (; it != pit->insetList().end(); ++it) {
-                       Inset & inset = *it->inset;
-                       if (inset.lyxCode() == CAPTION_CODE) {
-                               odocstringstream ods;
-                               InsetCaption * ins =
-                                       static_cast<InsetCaption *>(it->inset);
-                               ins->getCaptionText(ods, runparams);
-                               return ods.str();
-                       }
-               }
-       }
-       return docstring();
+       odocstringstream ods;
+       ins->getOptArg(ods, runparams);
+       ods << '[';
+       ins->getArgument(ods, runparams);
+       ods << ']';
+       return ods.str();
 }