X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Finsets%2FInsetFloat.cpp;h=021b7f3b17e805d6e05e5e72d1ab9cf5c102f875;hb=8d7b66e209cb640f6bbe2b5d01cda1dc50a2df7d;hp=07b5ece5b19041cbe3cefe1a52438852bd9eb545;hpb=9b111ea5a6b245464f77a095b050d846e807a21a;p=lyx.git diff --git a/src/insets/InsetFloat.cpp b/src/insets/InsetFloat.cpp index 07b5ece5b1..021b7f3b17 100644 --- a/src/insets/InsetFloat.cpp +++ b/src/insets/InsetFloat.cpp @@ -25,14 +25,14 @@ #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 "TexRow.h" +#include "texstream.h" #include "TextClass.h" -#include "support/convert.h" #include "support/debug.h" #include "support/docstream.h" #include "support/gettext.h" @@ -41,6 +41,7 @@ #include "frontends/Application.h" using namespace std; +using namespace lyx::support; namespace lyx { @@ -112,31 +113,38 @@ namespace lyx { // // Lgb - -InsetFloat::InsetFloat(Buffer const & buf, string const & type) - : InsetCollapsable(buf), name_(from_utf8(type)) +//FIXME: why do we set in stone the type here? +InsetFloat::InsetFloat(Buffer * buf, string params_str) + : InsetCaptionable(buf) { - setLabel(_("float: ") + floatName(type, buf.params())); - params_.type = type; + string2params(params_str, params_); + setCaptionType(params_.type); } -InsetFloat::~InsetFloat() +// Enforce equality of float type and caption type. +void InsetFloat::setCaptionType(std::string const & type) { - hideDialogs("float", this); + InsetCaptionable::setCaptionType(type); + params_.type = captionType(); + // check if the float type exists + if (buffer().params().documentClass().floats().typeExist(params_.type)) + setNewLabel(); + else + setLabel(bformat(_("ERROR: Unknown float type: %1$s"), from_utf8(params_.type))); } -docstring InsetFloat::name() const -{ - return "Float:" + name_; +docstring InsetFloat::layoutName() const +{ + return "Float:" + from_utf8(params_.type); } docstring InsetFloat::toolTip(BufferView const & bv, int x, int y) const { - if (InsetCollapsable::toolTip(bv, x, y).empty() || isOpen(bv)) - return docstring(); + if (isOpen(bv)) + return InsetCaptionable::toolTip(bv, x, y); OutputParams rp(&buffer().params().encoding()); return getCaptionText(rp); @@ -145,22 +153,25 @@ docstring InsetFloat::toolTip(BufferView const & bv, int x, int y) const void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd) { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: { InsetFloatParams params; string2params(to_utf8(cmd.argument()), params); + cur.recordUndoInset(this); // placement, wide and sideways are not used for subfloats if (!params_.subfloat) { 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(); + if (params_.type != params.type) + setCaptionType(params.type); + // what we really want here is a TOC update, but that means + // a full buffer update + cur.forceBufferUpdate(); break; } @@ -170,7 +181,7 @@ void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd) } default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCaptionable::doDispatch(cur, cmd); break; } } @@ -179,49 +190,48 @@ void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd) bool InsetFloat::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & flag) const { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: case LFUN_INSET_DIALOG_UPDATE: - case LFUN_INSET_SETTINGS: flag.setEnabled(true); return true; + case LFUN_INSET_SETTINGS: + if (InsetCaptionable::getStatus(cur, cmd, flag)) { + flag.setEnabled(flag.enabled() && !params_.subfloat); + return true; + } else + return false; + + case LFUN_NEWLINE_INSERT: + if (params_.subfloat) { + flag.setEnabled(false); + return true; + } + // no subfloat: + // fall through + default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCaptionable::getStatus(cur, cmd, flag); } } -void InsetFloat::updateLabels(ParIterator const & it) +bool InsetFloat::hasSubCaptions(ParIterator const & it) const { - Counters & cnts = - buffer().masterBuffer()->params().documentClass().counters(); - string const saveflt = cnts.current_float(); - bool const savesubflt = cnts.isSubfloat(); - - bool const subflt = (it.innerInsetOfType(FLOAT_CODE) - || it.innerInsetOfType(WRAP_CODE)); - // floats can only embed subfloats of their own kind - if (subflt) - params_.type = saveflt; - setSubfloat(subflt, buffer().params()); - - // Tell to captions what the current float is - cnts.current_float(params().type); - cnts.isSubfloat(subflt); - - InsetCollapsable::updateLabels(it); - - //reset afterwards - cnts.current_float(saveflt); - cnts.isSubfloat(savesubflt); + return (it.innerInsetOfType(FLOAT_CODE) || it.innerInsetOfType(WRAP_CODE)); } void InsetFloatParams::write(ostream & os) const { - os << "Float " << type << '\n'; + if (type.empty()) { + // Better this than creating a parse error. This in fact happens in the + // parameters dialog via InsetFloatParams::params2string. + os << "senseless" << '\n'; + } else + os << type << '\n'; if (!placement.empty()) os << "placement " << placement << "\n"; @@ -241,6 +251,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; @@ -250,15 +261,17 @@ void InsetFloatParams::read(Lexer & lex) void InsetFloat::write(ostream & os) const { + os << "Float "; params_.write(os); - InsetCollapsable::write(os); + InsetCaptionable::write(os); } void InsetFloat::read(Lexer & lex) { params_.read(lex); - InsetCollapsable::read(lex); + InsetCaptionable::read(lex); + setCaptionType(params_.type); } @@ -275,90 +288,128 @@ void InsetFloat::validate(LaTeXFeatures & features) const features.useFloat(params_.type, features.inFloat()); features.inFloat(true); - InsetCollapsable::validate(features); + InsetCaptionable::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 << 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. + 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::ESCAPE_NONE << ods.str(); + } + return deferred; } -int InsetFloat::latex(odocstream & os, OutputParams const & runparams_in) 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; - docstring const caption = getCaption(rp); - if (!caption.empty()) { - os << caption; - } + rp.moving_arg = true; + os << getCaption(rp); os << '{'; + // The main argument is the contents of the float. This is not a moving argument. + rp.moving_arg = false; rp.inFloat = OutputParams::SUBFLOAT; - int const i = InsetText::latex(os, rp); + InsetText::latex(os, rp); os << "}"; - - return i + 1; + + return; } OutputParams runparams(runparams_in); runparams.inFloat = OutputParams::MAINFLOAT; FloatList const & floats = buffer().params().documentClass().floats(); string tmptype = params_.type; - if (params_.sideways) + if (params_.sideways && floats.allowsSideways(params_.type)) tmptype = "sideways" + params_.type; - if (params_.wide && (!params_.sideways || - params_.type == "figure" || - params_.type == "table")) + if (params_.wide && floats.allowsWide(params_.type) + && (!params_.sideways || + params_.type == "figure" || + params_.type == "table")) tmptype += "*"; // Figure out the float placement to use. // From lowest to highest: // - float default placement // - document wide default placement // - specific float placement - string placement; + string tmpplacement; string const buf_placement = buffer().params().float_placement; string const def_placement = floats.defaultPlacement(params_.type); if (!params_.placement.empty() && params_.placement != def_placement) { - placement = params_.placement; + tmpplacement = params_.placement; } else if (params_.placement.empty() && !buf_placement.empty() && buf_placement != def_placement) { - placement = buf_placement; + tmpplacement = buf_placement; } - // The \n is used to force \begin{} to appear in a new line. - // The % is needed to prevent two consecutive \n chars in the case - // when the current output line is empty. - os << "%\n\\begin{" << from_ascii(tmptype) << '}'; + // Check if placement is allowed by this float + string const allowed_placement = + floats.allowedPlacement(params_.type); + string placement; + string::const_iterator lit = tmpplacement.begin(); + string::const_iterator end = tmpplacement.end(); + for (; lit != end; ++lit) { + if (contains(allowed_placement, *lit)) + placement += *lit; + } + + // Force \begin{} to appear in a new line. + os << breakln << "\\begin{" << from_ascii(tmptype) << '}'; + 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'; - int const i = InsetText::latex(os, runparams); - - // The \n is used to force \end{} to appear in a new line. - // In this case, we do not case if the current output line is empty. - os << "\n\\end{" << from_ascii(tmptype) << "}\n"; + InsetText::latex(os, runparams); - return i + 4; + // Force \end{} to appear in a new line. + os << breakln << "\\end{" << from_ascii(tmptype) << "}\n"; } -int InsetFloat::plaintext(odocstream & os, OutputParams const & runparams) const +int InsetFloat::plaintext(odocstringstream & os, OutputParams const & runparams, size_t max_length) const { os << '[' << buffer().B_("float") << ' ' - << floatName(params_.type, buffer().params()) << ":\n"; - InsetText::plaintext(os, runparams); + << floatName(params_.type) << ":\n"; + InsetText::plaintext(os, runparams, max_length); os << "\n]"; return PLAINTEXT_NEWLINE + 1; // one char on a separate line @@ -379,110 +430,101 @@ 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); -} - - -bool InsetFloat::showInsetDialog(BufferView * bv) const -{ - if (!InsetText::showInsetDialog(bv)) - bv->showDialog("float", params2string(params()), - const_cast(this)); - return true; + // 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 InsetCaptionable::insetAllowed(code); + } } -void InsetFloat::setWide(bool w, BufferParams const & bp, bool update_label) +void InsetFloat::setWide(bool w, bool update_label) { - params_.wide = w; + if (!buffer().params().documentClass().floats().allowsWide(params_.type)) + params_.wide = false; + else + 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 (!buffer().params().documentClass().floats().allowsSideways(params_.type)) + params_.sideways = false; + else + 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) + FloatList const & floats = buffer().params().documentClass().floats(); + + if (params_.wide && floats.allowsWide(params_.type)) lab += '*'; - if (params_.sideways) + if (params_.sideways && floats.allowsSideways(params_.type)) lab += _(" (sideways)"); setLabel(lab); } -docstring InsetFloat::getCaption(OutputParams const & runparams) const +bool InsetFloat::allowsCaptionVariation(std::string const & newtype) 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(it->inset); - ins->getOptArg(ods, runparams); - ods << '['; - ins->getArgument(ods, runparams); - ods << ']'; - return ods.str(); - } - } - } - return docstring(); + return !params_.subfloat && newtype != "Unnumbered"; } -docstring InsetFloat::getCaptionText(OutputParams const & runparams) const +TexString 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(it->inset); - ins->getCaptionText(ods, runparams); - return ods.str(); - } - } - } - return docstring(); + InsetCaption const * ins = getCaptionInset(); + if (ins == 0) + return TexString(); + + otexstringstream os; + ins->getArgs(os, runparams); + + if (!runparams.nice) + // increase TexRow precision in non-nice mode + os << safebreakln; + os << '['; + otexstringstream os2; + ins->getArgument(os2, runparams); + TexString ts = os2.release(); + docstring & arg = ts.str; + // Protect ']' + if (arg.find(']') != docstring::npos) + arg = '{' + arg + '}'; + os << move(ts); + os << ']'; + if (!runparams.nice) + os << safebreakln; + return os.release(); } @@ -496,8 +538,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); } @@ -505,7 +545,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(); }