X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetFloat.cpp;h=89a0fbe620bf00744105d37d453eedb3a1a9dd77;hb=04efc84abceb49e2042e357583a84b07847c1a5a;hp=56d57a8de80b505a93282f6d93eb5c3ce2b2ba05;hpb=ed858d73e57ce7aa89e38c1bc4d799362edb0227;p=lyx.git diff --git a/src/insets/InsetFloat.cpp b/src/insets/InsetFloat.cpp index 56d57a8de8..89a0fbe620 100644 --- a/src/insets/InsetFloat.cpp +++ b/src/insets/InsetFloat.cpp @@ -3,8 +3,9 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Jürgen Vigna - * \author Lars Gullik Bjønnes + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes + * \author Jürgen Spitzmüller * * Full author contact details are available in file CREDITS. */ @@ -12,35 +13,36 @@ #include #include "InsetFloat.h" +#include "InsetCaption.h" #include "Buffer.h" #include "BufferParams.h" #include "BufferView.h" #include "Counters.h" #include "Cursor.h" -#include "debug.h" #include "DispatchResult.h" #include "Floating.h" #include "FloatList.h" #include "FuncRequest.h" #include "FuncStatus.h" -#include "gettext.h" #include "LaTeXFeatures.h" #include "Lexer.h" -#include "OutputParams.h" +#include "output_xhtml.h" +#include "ParIterator.h" +#include "TextClass.h" +#include "support/debug.h" +#include "support/docstream.h" +#include "support/gettext.h" #include "support/lstrings.h" -#include "support/convert.h" +#include "frontends/Application.h" -namespace lyx { +using namespace std; +using namespace lyx::support; -using std::endl; -using std::string; -using std::istringstream; -using std::ostream; -using std::ostringstream; +namespace lyx { // With this inset it will be possible to support the latex package // float.sty, and I am sure that with this and some additional support @@ -48,7 +50,7 @@ using std::ostringstream; // (read DocBook). // By using float.sty we will have the same handling for all floats, both // for those already in existance (table and figure) and all user created -// ones¹. So suddenly we give the users the possibility of creating new +// ones¹. So suddenly we give the users the possibility of creating new // kinds of floats on the fly. (and with a uniform look) // // API to float.sty: @@ -85,7 +87,7 @@ using std::ostringstream; // \listof{type}{title} // title - -// ¹ the algorithm float is defined using the float.sty package. Like this +// ¹ the algorithm float is defined using the float.sty package. Like this // \floatstyle{ruled} // \newfloat{algorithm}{htbp}{loa}[] // \floatname{algorithm}{Algorithm} @@ -109,57 +111,75 @@ using std::ostringstream; // // Lgb +//FIXME: why do we set in stone the type here? +InsetFloat::InsetFloat(Buffer * buf, string params_str) + : InsetCaptionable(buf) +{ + string2params(params_str, params_); + setCaptionType(params_.type); +} + -InsetFloat::InsetFloat(BufferParams const & bp, string const & type) - : InsetCollapsable(bp), name_(from_utf8(type)) +// Enforce equality of float type and caption type. +void InsetFloat::setCaptionType(std::string const & type) { - setLabel(_("float: ") + floatName(type, bp)); - Font font(Font::ALL_SANE); - font.decSize(); - font.decSize(); - font.setColor(Color::collapsable); - setLabelFont(font); - params_.type = type; + 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::layoutName() const +{ + return "Float:" + from_utf8(params_.type); } -InsetFloat::~InsetFloat() +docstring InsetFloat::toolTip(BufferView const & bv, int x, int y) const { - InsetFloatMailer(*this).hideDialog(); + if (isOpen(bv)) + return InsetCaptionable::toolTip(bv, x, y); + + OutputParams rp(&buffer().params().encoding()); + return getCaptionText(rp); } void InsetFloat::doDispatch(Cursor & cur, FuncRequest & cmd) { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: { InsetFloatParams params; - InsetFloatMailer::string2params(to_utf8(cmd.argument()), params); - params_.placement = params.placement; - params_.wide = params.wide; - params_.sideways = params.sideways; - wide(params_.wide, cur.buffer().params()); - sideways(params_.sideways, cur.buffer().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; + } + 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; } case LFUN_INSET_DIALOG_UPDATE: { - InsetFloatMailer(*this).updateDialog(&cur.bv()); - break; - } - - case LFUN_MOUSE_RELEASE: { - if (cmd.button() == mouse_button::button3 && hitButton(cmd)) { - InsetFloatMailer(*this).showDialog(&cur.bv()); - break; - } - InsetCollapsable::doDispatch(cur, cmd); + cur.bv().updateDialog("float", params2string(params())); break; } default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCaptionable::doDispatch(cur, cmd); break; } } @@ -168,37 +188,46 @@ 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: - flag.enabled(true); + 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; + } + default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCaptionable::getStatus(cur, cmd, flag); } } -void InsetFloat::updateLabels(Buffer const & buf, ParIterator const & it) +bool InsetFloat::hasSubCaptions(ParIterator const & it) const { - Counters & cnts = buf.params().getTextClass().counters(); - string const saveflt = cnts.current_float(); - - // Tell to captions what the current float is - cnts.current_float(params().type); - - InsetCollapsable::updateLabels(buf, it); - - //reset afterwards - cnts.current_float(saveflt); + 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"; @@ -217,231 +246,304 @@ void InsetFloatParams::write(ostream & os) const void InsetFloatParams::read(Lexer & lex) { - string token; - lex >> token; - if (token == "placement") { + lex.setContext("InsetFloatParams::read"); + lex >> type; + if (lex.checkFor("placement")) lex >> placement; - } else { - // take countermeasures - lex.pushToken(token); - } - lex >> token; - if (token == "wide") { - lex >> wide; - } else { - lyxerr << "InsetFloat::Read:: Missing wide!" - << endl; - // take countermeasures - lex.pushToken(token); - } - lex >> token; - if (token == "sideways") { - lex >> sideways; - } else { - lyxerr << "InsetFloat::Read:: Missing sideways!" - << endl; - // take countermeasures - lex.pushToken(token); - } + lex >> "wide" >> wide; + lex >> "sideways" >> sideways; } -void InsetFloat::write(Buffer const & buf, ostream & os) const +void InsetFloat::write(ostream & os) const { + os << "Float "; params_.write(os); - InsetCollapsable::write(buf, os); + InsetCaptionable::write(os); } -void InsetFloat::read(Buffer const & buf, Lexer & lex) +void InsetFloat::read(Lexer & lex) { params_.read(lex); - wide(params_.wide, buf.params()); - sideways(params_.sideways, buf.params()); - InsetCollapsable::read(buf, lex); + InsetCaptionable::read(lex); + setCaptionType(params_.type); } void InsetFloat::validate(LaTeXFeatures & features) const { - if (support::contains(params_.placement, 'H')) { + if (support::contains(params_.placement, 'H')) features.require("float"); - } if (params_.sideways) - features.require("rotating"); - - features.useFloat(params_.type); - InsetCollapsable::validate(features); -} + features.require("rotfloat"); + if (features.inFloat()) + features.require("subfig"); -Inset * InsetFloat::clone() const -{ - return new InsetFloat(*this); + features.useFloat(params_.type, features.inFloat()); + features.inFloat(true); + InsetCaptionable::validate(features); + features.inFloat(false); } -docstring const 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(Buffer const & buf, odocstream & os, - OutputParams const & runparams) const +void InsetFloat::latex(otexstream & os, OutputParams const & runparams_in) const { - FloatList const & floats = buf.params().getTextClass().floats(); - string tmptype = (params_.wide ? params_.type + "*" : params_.type); - if (params_.sideways) { - if (params_.type == "table") - tmptype = "sidewaystable"; - else if (params_.type == "figure") - tmptype = "sidewaysfigure"; + if (runparams_in.inFloat != OutputParams::NONFLOAT) { + if (runparams_in.moving_arg) + os << "\\protect"; + os << "\\subfloat"; + + OutputParams rp = runparams_in; + rp.moving_arg = true; + getCaption(os, 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); + os << "}"; + + return; } + OutputParams runparams(runparams_in); + runparams.inFloat = OutputParams::MAINFLOAT; + + FloatList const & floats = buffer().params().documentClass().floats(); + string tmptype = params_.type; + if (params_.sideways && floats.allowsSideways(params_.type)) + tmptype = "sideways" + params_.type; + 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 const buf_placement = buf.params().float_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; + } + + // 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; } - // 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) << '}'; + // 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) { + if (!placement.empty() && !params_.sideways) os << '[' << from_ascii(placement) << ']'; - } os << '\n'; - int const i = InsetText::latex(buf, 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(Buffer const & buf, odocstream & os, - OutputParams const & runparams) const +int InsetFloat::plaintext(odocstringstream & os, OutputParams const & runparams, size_t max_length) const { - os << '[' << buf.B_("float") << ' ' << floatName(params_.type, buf.params()) << ":\n"; - InsetText::plaintext(buf, os, runparams); + os << '[' << buffer().B_("float") << ' ' + << floatName(params_.type) << ":\n"; + InsetText::plaintext(os, runparams, max_length); os << "\n]"; return PLAINTEXT_NEWLINE + 1; // one char on a separate line } -int InsetFloat::docbook(Buffer const & buf, odocstream & os, - OutputParams const & runparams) const +int InsetFloat::docbook(odocstream & os, OutputParams const & runparams) const { + // FIXME Implement subfloat! // FIXME UNICODE os << '<' << from_ascii(params_.type) << '>'; - int const i = InsetText::docbook(buf, os, runparams); + int const i = InsetText::docbook(os, runparams); os << "'; return i; } -bool InsetFloat::insetAllowed(Inset::Code code) const +bool InsetFloat::insetAllowed(InsetCode code) const { - return code != Inset::FLOAT_CODE - && code != Inset::FOOT_CODE - && code != Inset::MARGIN_CODE; + // 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); + } } -bool InsetFloat::showInsetDialog(BufferView * bv) const +void InsetFloat::setWide(bool w, bool update_label) { - if (!InsetText::showInsetDialog(bv)) - InsetFloatMailer(const_cast(*this)).showDialog(bv); - return true; + if (!buffer().params().documentClass().floats().allowsWide(params_.type)) + params_.wide = false; + else + params_.wide = w; + if (update_label) + setNewLabel(); } -void InsetFloat::wide(bool w, BufferParams const & bp) +void InsetFloat::setSideways(bool s, bool update_label) { - params_.wide = w; - docstring lab = _("float: ") + floatName(params_.type, bp); - if (params_.wide) - lab += '*'; - setLabel(lab); + if (!buffer().params().documentClass().floats().allowsSideways(params_.type)) + params_.sideways = false; + else + params_.sideways = s; + if (update_label) + setNewLabel(); } -void InsetFloat::sideways(bool s, BufferParams const & bp) +void InsetFloat::setSubfloat(bool s, bool update_label) { - params_.sideways = s; - docstring lab = _("float: ") + floatName(params_.type, bp); - if (params_.sideways) + params_.subfloat = s; + if (update_label) + setNewLabel(); +} + + +void InsetFloat::setNewLabel() +{ + docstring lab = _("float: "); + + if (params_.subfloat) + lab = _("subfloat: "); + + lab += floatName(params_.type); + + FloatList const & floats = buffer().params().documentClass().floats(); + + if (params_.wide && floats.allowsWide(params_.type)) + lab += '*'; + + if (params_.sideways && floats.allowsSideways(params_.type)) lab += _(" (sideways)"); + setLabel(lab); } -string const InsetFloatMailer::name_("float"); +bool InsetFloat::allowsCaptionVariation(std::string const & newtype) const +{ + return !params_.subfloat && newtype != "Unnumbered"; +} -InsetFloatMailer::InsetFloatMailer(InsetFloat & inset) - : inset_(inset) -{} + +docstring InsetFloat::getCaption(OutputParams const & runparams) const +{ + TexRow texrow(false); + odocstringstream ods; + otexstream os(ods, texrow); + getCaption(os, runparams); + return ods.str(); +} -string const InsetFloatMailer::inset2string(Buffer const &) const +void InsetFloat::getCaption(otexstream & os, + OutputParams const & runparams) const { - return params2string(inset_.params()); + if (paragraphs().empty()) + return; + + InsetCaption const * ins = getCaptionInset(); + if (ins == 0) + return; + + ins->getArgs(os, runparams); + + os << '['; + TexRow texrow; + odocstringstream ods; + otexstream oss(ods, texrow); + ins->getArgument(oss, runparams); + docstring arg = ods.str(); + // Protect ']' + if (arg.find(']') != docstring::npos) + arg = '{' + arg + '}'; + os.append(arg, texrow); + os << ']'; } -void InsetFloatMailer::string2params(string const & in, - InsetFloatParams & params) +void InsetFloat::string2params(string const & in, InsetFloatParams & params) { params = InsetFloatParams(); if (in.empty()) return; istringstream data(in); - Lexer lex(0,0); + Lexer lex; lex.setStream(data); - - string name; - lex >> name; - if (!lex || name != name_) - return print_mailer_error("InsetFloatMailer", in, 1, name_); - - // This is part of the inset proper that is usually swallowed - // by Text::readInset - string id; - lex >> id; - if (!lex || id != "Float") - return print_mailer_error("InsetBoxMailer", in, 2, "Float"); - - // We have to read the type here! - lex >> params.type; + lex.setContext("InsetFloat::string2params"); params.read(lex); } -string const InsetFloatMailer::params2string(InsetFloatParams const & params) +string InsetFloat::params2string(InsetFloatParams const & params) { ostringstream data; - data << name_ << ' '; params.write(data); return data.str(); }