Revert "Mark some intentional fall-throughs (in a way understandable to gcc)"

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

diff --git a/src/insets/InsetFloat.cpp b/src/insets/InsetFloat.cpp
index cfd40026777413c2b71a910e57297ef6cb1754ce..fcffac883abbff768267bb2b24a750e724f5bca8 100644 (file)
--- a/src/insets/InsetFloat.cpp
+++ b/src/insets/InsetFloat.cpp
@@ -29,6 +29,8 @@
 #include "Lexer.h"
 #include "output_xhtml.h"
 #include "ParIterator.h"
+#include "TexRow.h"
+#include "texstream.h"
 #include "TextClass.h"
 
 #include "support/debug.h"
@@ -123,18 +125,18 @@ InsetFloat::InsetFloat(Buffer * buf, string params_str)
 // Enforce equality of float type and caption type.
 void InsetFloat::setCaptionType(std::string const & type)
 {
-       InsetCaptionable::setCaptionType(type); 
+       InsetCaptionable::setCaptionType(type);
        params_.type = captionType();
        // check if the float type exists
        if (buffer().params().documentClass().floats().typeExist(params_.type))
-               setLabel(_("float: ") + floatName(params_.type));
+               setNewLabel();
        else
                setLabel(bformat(_("ERROR: Unknown float type: %1$s"), from_utf8(params_.type)));
 }
 
 
 docstring InsetFloat::layoutName() const
-{ 
+{
        return "Float:" + from_utf8(params_.type);
 }
 
@@ -201,7 +203,7 @@ bool InsetFloat::getStatus(Cursor & cur, FuncRequest const & cmd,
                        return true;
                } else
                        return false;
-       
+
        case LFUN_NEWLINE_INSERT:
                if (params_.subfloat) {
                        flag.setEnabled(false);
@@ -299,21 +301,22 @@ docstring InsetFloat::xhtml(XHTMLStream & xs, OutputParams const & rp) const
        odocstringstream ods;
        XHTMLStream newxs(ods);
        newxs << html::StartTag(htmltype, attr);
-       InsetText::XHTMLOptions const opts = 
+       InsetText::XHTMLOptions const opts =
                InsetText::WriteLabel | InsetText::WriteInnerTag;
        docstring deferred = InsetText::insetAsXHTML(newxs, rp, opts);
        newxs << html::EndTag(htmltype);
 
-       if (rp.inFloat == OutputParams::NONFLOAT)
+       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 
+       } 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 
+               // Note that things will already have been escaped, so we do not
                // want to escape them again.
                xs << XHTMLStream::ESCAPE_NONE << ods.str();
+       }
        return deferred;
 }
 
@@ -321,17 +324,19 @@ docstring InsetFloat::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 void InsetFloat::latex(otexstream & os, OutputParams const & runparams_in) const
 {
        if (runparams_in.inFloat != OutputParams::NONFLOAT) {
+               if (!paragraphs().empty() && !runparams_in.nice)
+                       // improve TexRow precision in non-nice mode
+                       os << safebreakln;
+
                if (runparams_in.moving_arg)
                        os << "\\protect";
                os << "\\subfloat";
 
                OutputParams rp = runparams_in;
                rp.moving_arg = true;
-               getCaption(os, rp);
+               os << getCaption(rp);
                os << '{';
                // The main argument is the contents of the float. This is not a moving argument.
-               if (!paragraphs().empty())
-                       os.texrow().forceStart(paragraphs()[0].id(), 0);
                rp.moving_arg = false;
                rp.inFloat = OutputParams::SUBFLOAT;
                InsetText::latex(os, rp);
@@ -384,8 +389,10 @@ void InsetFloat::latex(otexstream & os, OutputParams const & runparams_in) const
        if (runparams.lastid != -1)
                os.texrow().start(runparams.lastid, runparams.lastpos);
        // We only output placement if different from the def_placement.
-       // sidewaysfloats always use their own page
-       if (!placement.empty() && !params_.sideways)
+       // sidewaysfloats always use their own page,
+       // therefore don't output the p option that is always set
+       if (!placement.empty()
+           && (!params_.sideways || (params_.sideways && from_ascii(placement) != "p")))
                os << '[' << from_ascii(placement) << ']';
        os << '\n';
 
@@ -421,7 +428,7 @@ int InsetFloat::docbook(odocstream & os, OutputParams const & runparams) const
 
 bool InsetFloat::insetAllowed(InsetCode code) const
 {
-       // The case that code == FLOAT_CODE is handled in Text3.cpp, 
+       // 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:
@@ -487,43 +494,35 @@ void InsetFloat::setNewLabel()
 
 bool InsetFloat::allowsCaptionVariation(std::string const & newtype) const
 {
-       return !params_.subfloat && newtype != "LongTableNoNumber";
-}
-
-
-docstring InsetFloat::getCaption(OutputParams const & runparams) const
-{
-       TexRow texrow(false);
-       odocstringstream ods;
-       otexstream os(ods, texrow);
-       getCaption(os, runparams);
-       return ods.str();
+       return !params_.subfloat && newtype != "Unnumbered";
 }
 
 
-void InsetFloat::getCaption(otexstream & os,
-                                                       OutputParams const & runparams) const
+TexString InsetFloat::getCaption(OutputParams const & runparams) const
 {
-       if (paragraphs().empty())
-               return;
-
        InsetCaption const * ins = getCaptionInset();
        if (ins == 0)
-               return;
+               return TexString();
 
+       otexstringstream os;
        ins->getArgs(os, runparams);
 
+       if (!runparams.nice)
+               // increase TexRow precision in non-nice mode
+               os << safebreakln;
        os << '[';
-       TexRow texrow;
-       odocstringstream ods;
-       otexstream oss(ods, texrow);
-       ins->getArgument(oss, runparams);
-       docstring arg = ods.str();
+       otexstringstream os2;
+       ins->getArgument(os2, runparams);
+       TexString ts = os2.release();
+       docstring & arg = ts.str;
        // Protect ']'
        if (arg.find(']') != docstring::npos)
                arg = '{' + arg + '}';
-       os.append(arg, texrow);
+       os << move(ts);
        os << ']';
+       if (!runparams.nice)
+               os << safebreakln;
+       return os.release();
 }